Ejemplo para la Actividad de Laboratorio Nro. 2: Automatización de un Portón de Garaje utilizando como Modelo una MEF e implementando el sistema de control con Arduino. Objetivos Diseñar una MEF que que represente el sistema sistema de control para el problema. Conocer la placa Arduino y su plataforma de desarrollo. Diseñar un programa sobre el IDE Arduino que permita implementar la MEF. Conocer los circuitos electrónicos necesarios para la interface interface entre la placa Arduino y los componentes del sistema de control (botones, sensores, motor).
Planteo del problema de automatización del portón de garaje. Se pretende diseñar un sistema de control que permita controlar un portón de garaje automáticamente. El portón se abrirá cuando se pulse un botón verde y se cerrará cuando se pulse un botón rojo. La puerta dispondrá de dos sensores final de carrera, uno para detectar la la apertura total y otro para detectar el cierre total. Tanto los botones como los sensores devolverán valores lógicos (High=Verdadero o Low=Falso) de acuerdo a la situación que acontezca. Diseño del modelo MEF para el sistema de control. Teniendo en cuenta el funcionamiento del portón, definimos una MEF tipo MOORE, con los siguientes componentes: Estados: Q0 = Portón detenido Q1 = Portón cerrándose Q2 = Portón abriéndose
Salidas: Parar = detener motor Cerrar = avanzar motor Abrir = retroceder motor
Entradas: BV H = abrir portón BR H = cerrar portón S1 H = portón cerrado totalmente S2 H = portón abierto totalmente
BV L = no abrir BR L = no cerrar S1 L = no cerrado totalmente S2 L = no abierto totalmente
Q0/P
Q1/C
Q2/A
Tabla de Transición/Salida: ENTRADAS Valor SENSORES Decimal BV BR S1 S2 0 L L L L 1 L L L H 2 L L H L 3 L L H H 4 L H L L 5 L H L H 6 L H H L 7 L H H H 8 H L L L 9 H L L H 10 H L H L 11 H L H H 12 H H L L 13 H H L H 14 H H H L 15 H H H H
ESTADOS / SALIDAS 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
Implementación del sistema de control. Para la implementación del sistema de control utilizaremos una plataforma Arduino Mega ADK y los circuitos electrónicos necesarios para la interface entre el motor, los botones, los sensores y la placa Arduino. La lógica del modelo se implementará con un programa Arduino, realizado con la IDE Arduino 1.0. Introducción a la placa Arduino Arduino es una plataforma open-hardware basada en una sencilla placa con entradas y salidas (E/S), analógicas y digitales. En las entradas analógicas y digitales podemos conectar detectores y sensores. También 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 diseño como su distribución es libre. Es decir, puede utilizarse libremente para desarrollar cualquier tipo de proyecto sin tener que adquirir ningún 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 (Modulación por Ancho de Pulso), 16 canales de entradas analógicas, 4 UART (hardware serial ports), con un clock de 16 MHz. Tiene una conexión a USB para programación desde una PC, entrada de alimentación tipo Jack (7 a 12V) y conector ICSP (In Circuit Serial Programmer: método para programar microcontroladores sin tener que desmontarlos del circuito impreso, sirve para poder programar el bootloader de Arduino, que es el programa básico 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 alimentación tipo Jack. Programación de la Placa Arduino En primer lugar, debemos descargar el entorno de programación de la placa Arduino. Éste se puede encontrar en la siguiente web: http://arduino.cc/en/Main/Software A continuación, 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 número de ejemplos de proyectos de programación de la placa Arduino. Estos mismos proyectos serán accesibles directamente dentro del entorno de programación a través de un menú. o Directorio libraries : Este directorio contiene librerías adicionales al entorno de Arduino que se pueden añadir a los proyectos de programación para utilizar determinados dispositivos conectados a la placa. Por ejemplo, existe una librería ( Servo) para controlar servomotores, una librería (Wire) para comunicarse con dispositivos I2C y otra librería (LiquidCrystal ) para escribir en pantallas LED. o Directorio reference : Este directorio contiene en formato HTML la referencia básica del lenguaje de programación utilizado para programar la placa Arduino. Además, contiene también una referencia de las librerías incluidas en el directorio libraries. Para utilizar el entorno de programación 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. Configuración de la placa: En el menú Tools deberemos indicar el modelo de Arduino utilizado (opción Board ) y el puerto COM del PC donde está conectada la placa (opción Serial Port ). Si no estamos seguros del puerto utilizado, deberemos buscarlo en el Administrador de Dispositivos del sistema operativo. 2. Edición del código fuente del programa: Utilizaremos el panel central del entorno para teclear el código 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. Verificación y compilación del programa: Después de escribir el código fuente de nuestro programa, podremos verificar su sintaxis y compilarlo pulsando el botón “Verify” de la barra de herramientas (situado a la izquierda de la misma , icono “tilde” ). El resultado del proceso de compilación aparecerá en el panel de errores inferior. En caso de que haya algún error en el código, nos lo indicará la línea del código donde se encuentra para que lo podamos corregir. 4. Cargar el programa en la placa Arduino: Después de compilar un programa correcto, tendremos que cargarlo en el microcontrolador de la placa Arduino para poder ejecutarlo. Para ello, pulsaremos el botón “Upload” (segundo botón de la izquierda de la barra de herramientas, icono “flecha hacia derecha” ). Si la placa Arduino está correctamente conectada a nuestra PC, observaremos cómo 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 apagarán estos indicadores y comenzará la ejecución de nuestro programa en el microcontrolador de la placa. El lenguaje de programación de la placa Arduino utiliza una sintaxis muy parecida al lenguaje C aunque tiene una serie de particularidades propias de la programación de microcontroladores. En concreto, todo programa en Arduino deberá contener al menos dos funciones: setup() y loop(). La función setup() será ejecutada por el microcontrolador de la placa Arduino sólo una única vez, justo después de la transferencia del programa del PC a la placa. Por ello, esta función se utiliza generalmente para establecer modo de funcionamiento de los pines del Arduino (definirlos como entradas o salidas digitales mediante la función pinMode) y para abrir las comunicaciones de la placa (por ejemplo, el puerto serie o la comunicación I2C). La función loop() será ejecutada justo después de terminar la ejecución de la función setup(). Esta función implementará la lógica de nuestro programa. La función 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 activación posterior de los actuadores correspondientes asociados a las salidas de la placa (utilizando las funciones digitalWrite() y analogWrite()) según la lógica del sistema desarrollado. Debemos tener en cuenta que la ejecución de esta función será repetida indefinidamente por el microcontrolador, como si se encontrara dentro de un bucle infinito. Previo a estas dos funciones, se colocarán las “directivas de compilación” y “declaraciones globales” que sean necesarias.
Para comprender mejor todos estos elementos, es recomendable abrir y probar los distintos ejemplos de código presentes en el entorno Arduino (menú File/Examples). Para conocer la sintaxis del lenguaje y de sus principales funciones, se deberá consultar la documentación de referencia (directorio reference).
Circuitos de las entradas del sistema de control. Teniendo en cuenta el modelo MEF diseñado 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 utilizarán pulsadores “normal abiertos” y para los sensores de fin de carrera se utilizarán 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 colocación 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 botón 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 botón esté sin pulsar la entrada sea un nivel High estable. Teniendo en cuenta la corriente máxima de entrada de los pin de la Arduino y la tensión 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
1
IR
2
10K 4,7 F
3
6V 100
TSOP483
Circuitos de las salidas del sistema de control En nuestro caso el portón 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 portón que debe mover. En cualquier caso la corriente que debe suministrar el sistema de control es muy superior a la máxima 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 electromagnéticas. 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 electrónico conmutador, que utiliza un transistor BC548 que funciona como una llave electrónica 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 distribución de sus pines Colector, Base y Emisor:
6V
RELE
BC548
OUT Arduino
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 electroimán del RELE, para proteger el transistor y la propia Arduino del pulso de corriente que genera la bobina cuando
R1
se “abre” el circuito. Esa corriente se consume en el circuito que forma la bobina con el diodo,
que a propósito 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 según la polaridad de la alimentación, que se hace con una batería de 3V, se necesita un circuito inversor de polaridad. Este se logra con la combinación de dos circuitos conmutadores como el descripto anteriormente. De tal modo que con una salida más de la Arduino podemos controlar la polaridad, utilizamos el pin 41 que denominamos C2 en el programa. C1
La relación entre estos pines y las salidas de nuestro modelo MEF es: Parar Cerrar Abrir C2
6V
C1 L H H
C2 L L H
Programa Arduino para simular el sistema de control según el modelo MEF diseñado: #define Q0 0 // Portón parado #define Q1 1 // Portón abriéndose #define Q2 2 // Portón cerrándose #define BV #define BR #define S1 #define S2
45 // Botón Verde Abrir 47 // Botón 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); }
