Ejemplo para la Actividad de Laboratorio Nro.

2:

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: Salidas:
Q0 = Portn detenido Parar = detener motor
Q1 = Portn cerrndose Cerrar = avanzar motor
Q2 = Portn abrindose Abrir = retroceder motor

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











Q0/P Q2/A Q1/C
Tabla de Transicin/Salida:
ENTRADAS ESTADOS / SALIDAS
Valor
Decimal
SENSORES
BV BR S1 S2 Q0/Parar Q1/Cerrar Q2/Abrir
0 L L L L Q0 Q1 Q2
1 L L L H Q0 Q1 Q0
2 L L H L Q0 Q0 Q2
3 L L H H Q0 Q0 Q0
4 L H L L Q1 Q1 Q1
5 L H L H Q1 Q1 Q1
6 L H H L Q0 Q0 Q0
7 L H H H Q0 Q0 Q0
8 H L L L Q2 Q2 Q2
9 H L L H Q0 Q0 Q0
10 H L H L Q2 Q2 Q2
11 H L H H Q0 Q0 Q0
12 H H L L Q0 Q0 Q0
13 H H L H Q0 Q0 Q0
14 H H H L Q0 Q0 Q0
15 H H H H 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).





6 V
PIN
IR
10K
100
4,7 F
TSOP483
8
1
2
3
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.
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
6 V
C1
C2
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:










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.


La relacin entre estos pines y
las salidas de nuestro modelo
MEF es:













C1 C2
Parar L L
Cerrar H L
Abrir H H
BC548
OUT Arduino
RELE
R1
6 V
Programa Arduino para simular el sistema de control segn el modelo MEF diseado:

#define Q0 0 // Portn parado
#define Q1 1 // Portn abrindose
#define Q2 2 // Portn cerrndose

#define BV 45 // Botn Verde Abrir
#define BR 47 // Botn Rojo Cerrar
#define S1 30 // Sensor Cierre Total
#define S2 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);
}