Ejemplo para la Actividad de Laboratorio Nro.

3:
Automatizacin de un Portn de Garaje utilizando como Modelo
una MEF e implementando el sistema de control con Arduino.
Objetivos

Disear una MEF que represente el sistema de control para el problema.

Conocer la placa Arduino y su plataforma de desarrollo.
Disear un programa sobre el IDE Arduino que permita implementar la MEF.
Conocer los circuitos electrnicos necesarios para la interface entre la placa Arduino y
los componentes del sistema de control (botones, sensores, motor).

Planteo del problema de automatizacin del portn de garaje.

Se pretende disear un sistema de control que permita controlar un portn de garaje
automticamente. El portn se abrir cuando se pulse un botn verde y se cerrar cuando se
pulse un botn rojo. La puerta dispondr de dos sensores final de carrera, uno para detectar la
apertura total y otro para detectar el cierre total. Tanto los botones como los sensores devolvern
valores lgicos (High=Verdadero o Low=Falso) de acuerdo a la situacin que acontezca.

Diseo del modelo MEF para el sistema de control.

Teniendo en cuenta el funcionamiento del portn, definimos una MEF tipo MOORE, con los
siguientes componentes:
Estados:
Q0 = Portn detenido
Q1 = Portn cerrndose
Q2 = Portn abrindose

Salidas:
Parar = detener motor
Cerrar = avanzar motor
Abrir = retroceder motor

Entradas:
BV H = abrir portn
BR H = cerrar portn
S1 H = portn cerrado totalmente
S2 H = portn abierto totalmente

BV L = no abrir
BR L = no cerrar
S1 L = no cerrado totalmente
S2 L = no abierto totalmente

Q0/P

Tabla de Transicin/Salida:

Q1/C

Q2/A

ENTRADAS
Valor
SENSORES
Decimal BV BR S1
0
L
L
L
1
L
L
L
2
L
L
H
3
L
L
H
4
L
H
L
5
L
H
L
6
L
H
H
7
L
H
H
8
H
L
L
9
H
L
L
10
H
L
H
11
H
L
H
12
H
H
L
13
H
H
L
14
H
H
H
15
H
H
H

ESTADOS / SALIDAS
S2
L
H
L
H
L
H
L
H
L
H
L
H
L
H
L
H

Q0/Parar
Q0
Q0
Q0
Q0
Q1
Q1
Q0
Q0
Q2
Q0
Q2
Q0
Q0
Q0
Q0
Q0

Q1/Cerrar
Q1
Q1
Q0
Q0
Q1
Q1
Q0
Q0
Q2
Q0
Q2
Q0
Q0
Q0
Q0
Q0

Q2/Abrir
Q2
Q0
Q2
Q0
Q1
Q1
Q0
Q0
Q2
Q0
Q2
Q0
Q0
Q0
Q0
Q0

Implementacin del sistema de control.

Para la implementacin del sistema de control utilizaremos una plataforma Arduino Mega ADK y
los circuitos electrnicos necesarios para la interface entre el motor, los botones, los sensores y
la placa Arduino. La lgica del modelo se implementar con un programa Arduino, realizado con
la IDE Arduino 1.0.

Introduccin a la placa Arduino

Arduino es una plataforma open-hardware basada en una sencilla placa con entradas y salidas
(E/S), analgicas y digitales. En las entradas analgicas y digitales podemos conectar detectores
y sensores. Tambin podemos configurar las salidas para accionar luces, motores u otro tipo de
actuadores.

La placa Arduino se programa con un lenguaje propio, basado en Wiring, con sintaxis similar al
lenguaje C. El entorno de desarrollo (IDE) est hecho en Processing que es un lenguaje basado
en Java.
Al ser open-hardware tanto su diseo como su distribucin es libre. Es decir, puede utilizarse
libremente para desarrollar cualquier tipo de proyecto sin tener que adquirir ningn tipo de
licencia.
Existen varias versiones de Arduino. En nuestro laboratorio disponemos de la Arduino Mega ADK
(Kit de Desarrollo para Android). Esta placa tiene como micro-controlador el ATmega 2560.
Dispone de 54 I/O digital, de los cuales podemos usar 14 PWM (Modulacin por Ancho de Pulso),
16 canales de entradas analgicas, 4 UART (hardware serial ports), con un clock de 16 MHz.
Tiene una conexin a USB para programacin desde una PC, entrada de alimentacin tipo Jack
(7 a 12V) y conector ICSP (In Circuit Serial Programmer: mtodo para programar
microcontroladores sin tener que desmontarlos del circuito impreso, sirve para poder programar
el bootloader de Arduino, que es el programa bsico que escucha al puerto serie y as poder
descargar programas desde el IDE).
Para su funcionamiento solamente es necesario un cable USB para alimentarla desde la PC o
conectarla con una fuente externa mediante la entrada de alimentacin tipo Jack.

Programacin de la Placa Arduino

En primer lugar, debemos descargar el entorno de programacin de la placa Arduino. ste se
puede encontrar en la siguiente web: http://arduino.cc/en/Main/Software
A continuacin, deberemos descomprimir el fichero zip descargado. Este fichero contiene
diversos directorios entre los que destacan:
o Directorio drivers: Este directorio contiene los drivers para la placa Arduino. La primera
vez que conectemos la placa al PC mediante el cable USB, el sistema operativo nos pedir
instalar los drivers de la misma. En este momento, deberemos indicar al sistema operativo
que los busque en este directorio.
o Directorio examples: Este directorio contiene un gran nmero de ejemplos de proyectos
de programacin de la placa Arduino. Estos mismos proyectos sern accesibles
directamente dentro del entorno de programacin a travs de un men.
o Directorio libraries: Este directorio contiene libreras adicionales al entorno de Arduino que
se pueden aadir a los proyectos de programacin para utilizar determinados dispositivos
conectados a la placa. Por ejemplo, existe una librera (Servo) para controlar
servomotores, una librera (Wire) para comunicarse con dispositivos I2C y otra librera
(LiquidCrystal) para escribir en pantallas LED.
o Directorio reference: Este directorio contiene en formato HTML la referencia bsica del
lenguaje de programacin utilizado para programar la placa Arduino. Adems, contiene
tambin una referencia de las libreras incluidas en el directorio libraries.
Para utilizar el entorno de
programacin
de
Arduino,
tendremos que ejecutar el fichero
arduino.exe, contenido en el
fichero zip anterior.
Cuando deseemos desarrollar un
programa para la placa Arduino
con este entorno, deberemos
seguir los siguientes pasos:

1. Configuracin de la placa: En el men Tools deberemos indicar el modelo de Arduino utilizado

(opcin Board) y el puerto COM del PC donde est conectada la placa (opcin Serial Port). Si no
estamos seguros del puerto utilizado, deberemos buscarlo en el Administrador de Dispositivos
del sistema operativo.
2. Edicin del cdigo fuente del programa: Utilizaremos el panel central del entorno para teclear
el cdigo fuente de nuestro programa. Podremos utilizar los botones centrales de la barra de
herramientas para crear un nuevo fichero, abrir uno existente o guardar el actual.
3. Verificacin y compilacin del programa: Despus de escribir el cdigo fuente de nuestro
programa, podremos verificar su sintaxis y compilarlo pulsando el botn Verify de la barra de
herramientas (situado a la izquierda de la misma, icono tilde). El resultado del proceso de
compilacin aparecer en el panel de errores inferior. En caso de que haya algn error en el
cdigo, nos lo indicar la lnea del cdigo donde se encuentra para que lo podamos corregir.
4. Cargar el programa en la placa Arduino: Despus de compilar un programa correcto,
tendremos que cargarlo en el microcontrolador de la placa Arduino para poder ejecutarlo. Para
ello, pulsaremos el botn Upload (segundo botn de la izquierda de la barra de herramientas,
icono flecha hacia derecha). Si la placa Arduino est correctamente conectada a nuestra PC,
observaremos cmo se iluminan los indicadores TX y RX de la placa mientras el programa se
est transfiriendo del PC a la placa. Cuando termine este proceso, se apagarn estos indicadores
y comenzar la ejecucin de nuestro programa en el microcontrolador de la placa.
El lenguaje de programacin de la placa Arduino utiliza una sintaxis muy parecida al lenguaje C
aunque tiene una serie de particularidades propias de la programacin de microcontroladores.
En concreto, todo programa en Arduino deber contener al menos dos funciones: setup() y loop().
La funcin setup() ser ejecutada por el microcontrolador de la placa Arduino slo una
nica vez, justo despus de la transferencia del programa del PC a la placa. Por ello, esta
funcin se utiliza generalmente para establecer modo de funcionamiento de los pines del
Arduino (definirlos como entradas o salidas digitales mediante la funcin pinMode) y para
abrir las comunicaciones de la placa (por ejemplo, el puerto serie o la comunicacin I2C).
La funcin loop() ser ejecutada justo despus de terminar la ejecucin de la funcin
setup(). Esta funcin implementar la lgica de nuestro programa. La funcin loop() se
suele organizar realizando primero una lectura de los sensores conectados a las entradas
de la placa (utilizando las funciones digitalRead() y analogRead()) y en la activacin
posterior de los actuadores correspondientes asociados a las salidas de la placa
(utilizando las funciones digitalWrite() y analogWrite()) segn la lgica del sistema
desarrollado. Debemos tener en cuenta que la ejecucin de esta funcin ser repetida
indefinidamente por el microcontrolador, como si se encontrara dentro de un bucle infinito.
Previo a estas dos funciones, se colocarn las directivas de compilacin y declaraciones
globales que sean necesarias.
Para comprender mejor todos estos elementos, es recomendable abrir y probar los distintos
ejemplos de cdigo presentes en el entorno Arduino (men File/Examples). Para conocer la
sintaxis del lenguaje y de sus principales funciones, se deber consultar la documentacin de
referencia (directorio reference).

Circuitos de las entradas del sistema de control.

Teniendo en cuenta el modelo MEF diseado previamente, se deber conectar cada elemento
de entrada (pulsadores verde/rojo, sensores de fin de carrera izquierdo y derecho, sensor de IR

del control remoto) al pin correspondiente de entrada de la placa Arduino. Utilizaremos los
siguientes pines en correspondencia a las entradas: BV pin 45, BR pin 47, S1 pin 30, S2 pin
31 e ir pin 49..
Para los botones de cierre y apertura se utilizarn pulsadores normal abiertos y para los
sensores de fin de carrera se utilizarn pulsadores normal cerrados.
Un detalle importante a tener en cuenta cuando se conecta un pin de entrada de la Arduino, a un
nivel de voltaje Low (0V) o High (5V) mediante pulsadores, es la colocacin de resistencias de
pull-up o pull-down respectivamente.
Cuando se utiliza un pulsador normal abierto para
introducir un nivel High, se debe conectar una resistencia (pull-down) desde la entrada a GND
(tierra o masa = 0V) para que mientras el botn est sin pulsar la entrada sea un nivel Low
estable. Cuando se utiliza un pulsador normal cerrado para introducir un nivel Low, se debe
conectar una resistencia (pull-up) desde la entrada a 5V, para que mientras el botn est sin
pulsar la entrada sea un nivel High estable. Teniendo en cuenta la corriente mxima de entrada
de los pin de la Arduino y la tensin de salida interna de la placa (5V), se requiere resistencias
de 10KOhms.
Por ltimo, necesitamos un circuito para el sensor de rayos infrarrojos (TSOP4838) provenientes
del control remoto NEC.

PIN
IR

10K

4,7 F
3

6V
100

TSOP483

8
Circuitos de las salidas del sistema de control
En nuestro caso el portn se desplaza horizontalmente sobre dos ruedas que se deslizan sobre
un riel y tiene en su parte superior una cremallera que es accionada por la rueda dentada de un
motor. En la maqueta que hemos construido para probar este sistema de control, hemos
utilizado un motor de corriente continua del Kit Motobox de Rasti, consume entre 250 y 750mA.
En un caso real el motor de corriente alterna puede consumir varios Amperios dependiendo de
la potencia que tenga, que a la vez depende del peso del portn que debe mover. En cualquier
caso la corriente que debe suministrar el sistema de control es muy superior a la mxima que
puede proporcionar un pin de la Arduino, que a lo sumo llega a 40mA.
Esto requiere que entre el pin de salida de la placa y el control del motor tengamos una interface.
El circuito del motor debe ser independiente del circuito de control y de la placa Arduino. Esto
se logra mediante el uso de Relevadores-Contactores (RELE) que funcionan como llaves
electromagnticas. Hemos utilizado RELE que tienen electroimanes de 6V y consumen una
corriente de 150mA. Esto hace necesario otra interface para poder accionar estos RELE
mediante una salida de la Arduino. En este caso utilizamos un circuito electrnico conmutador,
que utiliza un transistor BC548 que funciona como una llave electrnica y apenas consume unos
5mA, pudiendo suministrar hasta 200mA en su salida, lo que es suficiente para controlar el RELE,
con una fuente externa de 6V.

El circuito completo es el siguiente:

El transistor BC548 es un NPN con la
siguiente distribucin de sus pines
Colector, Base y Emisor:

+6V

PIN 40

BC548

La resistencia R1 sirve para alimentar el

transistor y debe ser de unos 220 Ohms,
el diodo D1 se coloca paralelo a la bobina
del electroimn del RELE, para proteger el
transistor y la propia Arduino del pulso de
corriente que genera la bobina cuando se
abre el circuito. Esa corriente se consume en el circuito que forma la bobina con el diodo, que
a propsito se us un LED para ver este efecto como un destello de luz, cada vez que se realiza
una parada del motor. En particular usamos el pin 40 de la Arduino como salida para controlar
este conmutador, que llamamos C1 en el programa.
Por tratarse de un motor de corriente continua, que gira en un sentido u otro segn la polaridad
de la alimentacin, que se hace con una batera de 3V, se necesita un circuito inversor de
polaridad. Este se logra con la combinacin de dos circuitos conmutadores como el descripto
anteriormente. De tal modo que con una salida ms de la Arduino podemos controlar la
polaridad, utilizamos el pin 41 que denominamos C2 en el programa.
C1

La relacin entre estos pines y las

salidas de nuestro modelo MEF
es:

Parar
Cerrar
Abrir

C1
L
H
H

C2
L
L
H

C2
6V

Programa Arduino para simular el sistema de control segn el modelo MEF diseado:

#define Q0 0 // Portn parado

#define Q1 1 // Portn cerrndose
#define Q2 2 // Portn abrindose
#define BV
#define BR
#define S1
#define S2

45 // Botn Verde Abrir

47 // Botn Rojo Cerrar
30 // Sensor Cierre Total
31 // Sensor Apertura Total

#define C1 40 // Salida On-Off Motor

#define C2 41 // Salida Giro Izq-Der Motor
int tablaTran[16][3] = {{Q0,Q1,Q2}, {Q0,Q1,Q0}, {Q0,Q0,Q2}, {Q0,Q0,Q0},
{Q1,Q1,Q1}, {Q1,Q1,Q1}, {Q0,Q0,Q0}, {Q0,Q0,Q0}, {Q2,Q2,Q2}, {Q0,Q0,Q0},
{Q2,Q2,Q2}, {Q0,Q0,Q0}, {Q0,Q0,Q0}, {Q0,Q0,Q0}, {Q0,Q0,Q0}, {Q0,Q0,Q0}};
int tablaSalida[3][2] = {{LOW,LOW},{LOW,HIGH},{HIGH,HIGH}};
int estado = Q0, fila;
int lectura_entradas()
{
return digitalRead(BV)*8+digitalRead(BR)*4+digitalRead(S1)*2+digitalRead(S2);
}
void escritura_salidas(int estado)
{
digitalWrite(C1, tablaSalida[estado][0]);
digitalWrite(C2, tablaSalida[estado][1]);
}
void setup()
{
pinMode(BV, INPUT);
pinMode(BR, INPUT);
pinMode(S1, INPUT);
pinMode(S2, INPUT);
pinMode(C1, OUTPUT);
pinMode(C2, OUTPUT);
}
void loop()
{
fila = lectura_entradas();
estado = tablaTran[fila][estado];
escritura_salidas(estado);
}