Universidad Politécnica de Victoria ESTANCIA II
Diseño de un sistema de control domótico basado en la plataforma plataforma Processing-Arduino Processing-Arduino
Ingeniería Mecatrónica
Organismo receptor:
Ortopedia Ledezma Carretera Soto la Marina, colonia Horacio Terán Número interior #423 #423 Autor: Gonzalo Loredo Neri Asesor Empresarial: CPO II Santiago Ledezma Pineda
Asesor Institucional:
M.I. Carlos Federico Puga Banda
Estancias II 2013
Índice 1. ABSTRACT. .......................... ......................................... ............................. ............................ ............................ ............................ ............................ ............................ ............................. ......................... .......... 3 2. INTRODUCCIÓN. ........................... ......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................. ................. 4 3. MARCO TEÓRICO. ........................... ......................................... ............................ ............................. ............................. ............................ ............................ ............................ ........................... ............. 5 3.1. Conceptos sobre domótica. .................................................................................................... 5
3.1.1. Domótica. .......................................................................................................................... 5 3.1.2. Los dispositivos. dispositivos. ................................................................................................................ 5 3.1.3. Controlador........................................................................................................................ 5 3.1.4. Actuador ............................................................................................................................ 5 3.1.5. Sensor. ............................................................................................................................... 5 3.1.6. Bus..................................................................................................................................... 5 3.1.7. Interface............................................................................................................................. 5 3.1.8. Proteus® ........................................................................................................................... 6 3.1.9. Processing® ...................................................................................................................... 6 4. OBJETIVOS. ........................... ......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................. ....................... ........ 7 4.1. Objetivo general. .................................................................................................................... 7 4.2. Objetivos particulares. ........................................................................................................... 7 5. JUSTIFICACIÓN. ............................ .......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................. ................. 7 6. CARACTERÍSTICAS DE ARDUINO ARDUINO Y PROCESSING. ............................ ........................................... ............................. ............................ ............................ .................... ...... 8 6.1. Hardware. ............................................................................................................................... 8
6.1.1. Arduino Uno. ..................................................................................................................... 8 6.2. Software. ............................................................................................................................... 12
6.2.1. Arduino-1.5.3. ................................................................................................................. 12 6.2.2. Processing-2.0.2. ............................................................................................................. 14 7. DISPOSITIVOS COMPATIBLES COMPATIBLES CON ARDUINO. ARDUINO. ............................ .......................................... ............................ ............................ ............................ ....................... ......... 15 8. PROTOTIPO DE INTERFAZ DOMÓTICA. ........................... ......................................... ............................ ............................ ............................ ............................. ..................... ...... 23 9. CONEXIONES FÍSICAS. ........................... ......................................... ............................ ............................. ............................. ............................ ............................ ............................ .................. .... 33 10. RESULTADOS. .......................... ......................................... ............................. ............................ ............................ ............................ ............................ ............................ ............................ .................. 36 11. CONCLUSIÓN. ............................ .......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................ .............. 37 12. REFERENCIAS. ............................ .......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................ .............. 37
2
Estancias II 2013
Índice 1. ABSTRACT. .......................... ......................................... ............................. ............................ ............................ ............................ ............................ ............................ ............................. ......................... .......... 3 2. INTRODUCCIÓN. ........................... ......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................. ................. 4 3. MARCO TEÓRICO. ........................... ......................................... ............................ ............................. ............................. ............................ ............................ ............................ ........................... ............. 5 3.1. Conceptos sobre domótica. .................................................................................................... 5
3.1.1. Domótica. .......................................................................................................................... 5 3.1.2. Los dispositivos. dispositivos. ................................................................................................................ 5 3.1.3. Controlador........................................................................................................................ 5 3.1.4. Actuador ............................................................................................................................ 5 3.1.5. Sensor. ............................................................................................................................... 5 3.1.6. Bus..................................................................................................................................... 5 3.1.7. Interface............................................................................................................................. 5 3.1.8. Proteus® ........................................................................................................................... 6 3.1.9. Processing® ...................................................................................................................... 6 4. OBJETIVOS. ........................... ......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................. ....................... ........ 7 4.1. Objetivo general. .................................................................................................................... 7 4.2. Objetivos particulares. ........................................................................................................... 7 5. JUSTIFICACIÓN. ............................ .......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................. ................. 7 6. CARACTERÍSTICAS DE ARDUINO ARDUINO Y PROCESSING. ............................ ........................................... ............................. ............................ ............................ .................... ...... 8 6.1. Hardware. ............................................................................................................................... 8
6.1.1. Arduino Uno. ..................................................................................................................... 8 6.2. Software. ............................................................................................................................... 12
6.2.1. Arduino-1.5.3. ................................................................................................................. 12 6.2.2. Processing-2.0.2. ............................................................................................................. 14 7. DISPOSITIVOS COMPATIBLES COMPATIBLES CON ARDUINO. ARDUINO. ............................ .......................................... ............................ ............................ ............................ ....................... ......... 15 8. PROTOTIPO DE INTERFAZ DOMÓTICA. ........................... ......................................... ............................ ............................ ............................ ............................. ..................... ...... 23 9. CONEXIONES FÍSICAS. ........................... ......................................... ............................ ............................. ............................. ............................ ............................ ............................ .................. .... 33 10. RESULTADOS. .......................... ......................................... ............................. ............................ ............................ ............................ ............................ ............................ ............................ .................. 36 11. CONCLUSIÓN. ............................ .......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................ .............. 37 12. REFERENCIAS. ............................ .......................................... ............................ ............................ ............................ ............................ ............................ ............................ ............................ .............. 37
2
Estancias II 2013
1. ABSTRACT. In this paper has described the basic knowledge to understand what it is and how it works a home automation system and how using the free of Arduino hardware and the software free of Processing is you can create a stable system with a budget very much lower than in the homes of high category. The document has been divided into a series of stages in which they are to treat each item in a comprehensive but simple, i.e. it will give you the information needed to understand the process of creating a home automation system without superfluous details. In the introduction is going to be able to take a first step in the world of home automation and know because of the use of Arduino and processing. After you learn how they are constructed the Arduino boards and working environment that we have to be rescheduled. It is also important to discuss the different devices, that we can attach to a plate to add functionality to your home automation system. Given that the part of management of the system is more complex emphasis will be placed on it by offering various forms of communication between the plates arguing their advantages and disadvantages. He then exposes a simple home automation system in which they apply the knowledge acquired. All of the information in the memory has been reinforced with images to know of a way visual on what we are talking about.
3
Estancias II 2013
2. INTRODUCCIÓN. Aunque el ser humano todavía no está arraigado a las propiedades que ofrece la domótica es un hecho que en un futuro estará instalada en cualquier vivienda. Pero ¿qué es la domótica? Se podría definir como el conjunto de tecnologías aplicadas al control y la automatización inteligente de la vivienda, que permite una gestión eficiente del uso de la energía además de aportar seguridad, confort, y comunicación entre el usuario y el sistema. Para poder conseguir las propiedades comentadas anteriormente es necesario que los sistemas recojan la información de su entorno con sensores y dispongan de la lógica para actuar en consecuencia utilizando actuadores. En este proyecto se utilizó la plataforma Arduino en la que se apoyaran con otros dispositivos para poder construir un sistema domótico simple. Arduino es una plataforma de hardware libre creada en 2005, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares. Luego está el factor estético que normalmente evitaría la instalación de cableado para comunicar las placas Arduino, es decir, se aprovechan dispositivos que trabajen inalámbricamente. Aunque el precio de un dispositivo inalámbrico es ligeramente superior, se puede evitar tener que comprar cables que poco a poco aumentaría el coste total haciéndolo incluso más caro. Pero también se debe saber que los elementos inalámbricos interfieren entre sí y eso por ejemplo en una zona densamente habitada en el que los vecinos también dispongan de este tipo aparatos puede reducir las prestaciones de la comunicación del sistema. Es por ello que cada caso hay que estudiarlo por separado y actuar en consecuencia.
4
Estancias II 2013
3. MARCO TEÓRICO. En esta parte se presentan conceptos básicos relacionados con el contenido de este documento abarcando temas que permiten el mejor entendimiento de la domótica, y del hardware y software utilizados. 3.1. Conceptos sobre domótica. 3.1.1. Domótica.
La domótica es la automatización y control centralizado y/o remoto de aparatos y sistemas eléctricos y electrotécnicos en la vivienda. Los objetivos principales de la domótica es aumentar el confort, ahorrar energía y mejorar la seguridad. [1] 3.1.2. Los dispositivos.
La amplitud de una solución de domótica puede variar desde un único dispositivo, que realiza una sola acción, hasta amplios sistemas que controlan prácticamente todas las instalaciones dentro de la vivienda. [1] 3.1.3. Controlador.
Los controladores son los dispositivos que gestionan el sistema según la programación y la información que reciben. Puede haber un controlador solo, o varios distribuidos por el sistema. 3.1.4. Actuador
El actuador es un dispositivo capaz de ejecutar y/o recibir una orden del controlador y realizar una acción sobre un aparato o sistema (encendido/apagado, subida/bajada, apertura/cierre, etc.). [1] 3.1.5. Sensor.
El sensor es el dispositivo que monitoriza el entorno captando información que transmite al sistema (sensores de agua, gas, humo, temperatura, viento, humedad, lluvia, iluminación, etc.). [1] 3.1.6. Bus.
Es bus es el medio de transmisión que transporta la información entre los distintos dispositivos por un cableado propio, por la redes de otros sistemas (red eléctrica, red telefónica, red de datos) o de forma inalámbrica. [1] 3.1.7. Interface.
Los interfaces refiere a los dispositivos (pantallas, móvil, Internet, conectores) y los
5
Estancias II 2013 formatos (binario, audio) en que se muestra la información del sistema para los usuarios (u otros sistemas) y donde los mismos pueden interactuar con el sistema. [1] 3.1.8. Proteus ® Proteus es una compilación de por Labcenter Electronics que
programas de diseño y simulación electrónica, desarrollado consta de los dos programas principales: Ares e Isis, y los
módulos VSM y Electra. 3.1.9. Processing®
Es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java, de fácil utilización, y que sirve como medio para la enseñanza y producción de proyectos multimedia e interactivos de diseño digital. Fue iniciado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics and Computation Group del MIT Media Lab dirigido por John Maeda.
6
Estancias II 2013
4. OBJETIVOS. 4.1. Objetivo general.
Como objetivo de este proyecto se ha propuesto crear un sistema domótico simple utilizando las placas de bajo coste Arduino y otros dispositivos, como sensores, actuadores y comunicadores, dicho sistema estará controlado mediante una interfaz diseñada en Processing. Habrá que dotar al sistema de la lógica necesaria para que puedan comunicarse las placas que estarán controlando la habitación en la cual hayan sido instaladas. 4.2. Objetivos particulares.
Diseñar una interfaz en Processing que permita controlar el encendido o apagado de los actuadores (regulación de iluminación y regulación de climatización). Construir una pequeña etapa de potencia que permita aislar el Arduino de sobrecargas. Realizar el encendido y apagado de un foco, representando todos los focos pertenecientes a los cuartos de una casa. Diseñar un control de temperatura utilizando un sensor de humedad y temperatura.
5. JUSTIFICACIÓN. El objetivo del uso de la domótica es el aumento del confort, el ahorro energético y mejora la seguridad personal y patrimonial en la vivienda. Actualmente los sistemas domóticos tienen un precio muy alto de instalación con lo cual solo es posible verlo en casas de lujo. Estos suelen utilizar buses de transmisión de información que posibilitan una domótica robusta como son el EIB, X10, CEBus, LonWorks/LongTalk y ZigBee. Una alternativa más barata y casera consiste en la utilización de placas Arduino.
7
Estancias II 2013
6. CARACTERÍSTICAS DE ARDUINO Y PROCESSING. En este apartado se describirán los principales elementos que componen una placa Arduino y el entorno de desarrollo en el que se programa el código, es decir la parte hardware y software (interface en Processing) que actúan sobre Arduino. 6.1. Hardware.
Al ser Arduino una plataforma de hardware libre tanto su diseño como su distribución puede utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia. Por eso existen varios tipos de placa oficiales, las creadas por la comunidad Arduino o las no oficiales creadas por terceros pero con características similares. En la placa Arduino es donde se conectaran los sensores, actuadores y otros elementos necesarios para realizar la comunicación con el sistema. En el proyecto se ha utilizado la placa Arduino Uno que se describirá a continuación. 6.1.1. Arduino Uno.
Es el último modelo diseñado y distribuido por la comunidad Arduino. La placa tiene un tamaño de 75x53mm. Su unidad de procesamiento consiste en un microcontrolador ATmega328. Puede ser alimentada mediante USB o alimentación externa y contiene pines tanto analógicos como digitales. En la figura 6.1 se observa como es la tarjeta Arduino Uno físicamente y se aprecian sus entradas y salidas.
F igur a 6.1. Arduino Uno, se pueden observar los pines entradas / salidas, el
microcontrolador, etc.
8
Estancias II 2013
La tabla siguiente resume sus componentes: Tabla 1. Características del Arduino Uno.
Componente
Características
Microcontrolador ATmega328 Voltaje operativo 5V Voltaje de entrada(recomendado) 7-12V Voltaje de entrada (limites) 6-20V Pines digitales E/S 14 (de los cuales 6 proporcionan salida PWM) Pines de entrada analógica 6 Corriente continua para pines E/S 40 mA Corriente continua para pines de 50 mA 3.3V Memoria Flash 32 KB (ATmega328) SRAM 2 KB (ATmega328) EEPROM 1 KB (ATmega328) Velocidad del reloj 16 MHz A continuación se muestra en la figura 6.2 donde están ubicados los elementos más importantes que componen la placa Arduino Uno:
F igura 6.2. Elementos de la placa Arduino Uno.
9
Estancias II 2013 Referencia para pines analógicos (AREF)
Tensión de referencia para entradas analógicas. Se utiliza con la función analogReference(). Pines de tierra (GND)
Masa del circuito para pines, es decir es la tensión de referencia de 0V. Pines digitales de entrada y salida
En estos pines se conecta la patilla de dato del sensor/actuador. Desde ellos se puede leer la información del sensor o activar el actuador. Hay 14 pines digitales que pueden utilizarse como entrada o salida con las funciones pinMode(), digitalWrite(), y digitalRead(). Operan a 5 voltios. Cada pin proporciona o recibe como máximo 40mA y disponen de una resistencia pull-up (desconectada por defecto) de 20-50 kOhmios. Son reservados para determinados usos:
Serie: 0(RX) y 1(TX). Utilizados para recibir (RX) y trasmitir (TX) datos serie. Están directamente conectados a los pines serie del microcontrolador. Utilizando estos pines es posible conectarse con otras placas. Interrupciones externas: 2 y 3. Estos pines pueden ser configurados para activar interrupciones. PWM: 3, 5, 6, 9, 10 y 11. Proporcionan una salida de 8 bits en modo PWM. SPI: 10-13. Estos pines soportan la librería de comunicación de dispositivos SPI. LED: 13. Este pin está conectado con un led de la placa. Cuando se le asigne un valor HIGH se encenderá, en cambio sí se deja en LOW estará apagado.
Conector USB
Existen varios tipos de conectores USB, en concreto esta placa utiliza el tipo B hembra. Con lo cual se necesitará un cable tipo B macho – tipo A macho (aunque se pueden utilizar otros este es el más extendido) que deberá conectarse a un conector tipo A hembra (por ejemplo a un ordenador o al cargador de un móvil). La placa se puede alimentar con la tensión de 5V que le proporciona el bus serie USB. Cuando se cargue un programa a la placa desde el software de Arduino se inyectará el código del ordenador por este bus. Botón Reset
Utilizando este botón se puede reiniciar la ejecución del código del microcontrolador. ICSP (In Circuit Serial Programming)
Es un conector utilizado en los dispositivos PIC para programarlos sin necesidad de tener que retirar el chip del circuito del que forma parte.
10
Estancias II 2013 Microcontrolador ATmega328
El microcontrolador es el elemento más importante de la placa. Es donde se instalará y ejecutará el código que se haya diseñado. Ha sido creado por la compañía Atmel, tiene un voltaje operativo de 5V, aunque se recomienda como entrada de 7-12V con un límite de 20V. Contiene 14 pines digitales de entrada y salida, 6 pines analógicos que están conectados directamente a los pines de la placa Arduino comentados anteriormente. Dispone de 32KB de memoria flash (de los cuales 512 bytes son utilizados por el bootloader). En la memoria flash se instalará el programa a ejecutar. El bootloader será el encargado de preparar el microcontrolador para que pueda ejecutar el programa. También tiene una memoria EEPROM de 1KB que puede ser leída o escrita con la librería EEPROM. En la parte de procesamiento dispone de un reloj de 16Mhz y 2KB de memoria RAM. Fuente de alimentación externa
La placa puede ser alimentada también mediante corriente continua suministrada por el conector Jack de 3.5 mm que podrá recibir entre 7 y 12V. Pin de Reset
Se puede imitar el funcionamiento del botón reset suministrando un valor LOW(0V) para reiniciar el microcontrolador. Pin de 3.3V
Desde aquí se puede suministrar 3.3V a los dispositivos que lo necesiten con una corriente máxima de 50mA. Es generada gracias al chip FTDI integrado en la placa. Pin de 5V
Este pin saca una tensión de 5v del regulador de la placa. El regulador es necesario puesto que puede ser alimentada con distintos voltajes. Pin de Vin
Es el voltaje de entrada cuando se usa una fuente de alimentación externa (no tiene en cuenta la conexión USB). Se puede proporcionar voltaje a la placa a través de este pin, o en caso de que se esté utilizando una fuente de alimentación externa tomar el valor que está siendo suministrado. Pines analógicos
Esta placa contiene 6 pines de entrada analógicos. Los elementos que se conecten aquí suelen tener mayor precisión que los digitales pero su uso requiere de una lógica levemente mayor. Más adelante se comentará el uso de un termistor analógico.
11
Estancias II 2013 6.2. Software. 6.2.1. Arduino-1.5.3.
La plataforma Arduino tiene un lenguaje propio que está basado en C/C++ y por ello soporta las funciones del estándar C y algunas de C++. Sin embargo, es posible utilizar otros lenguajes de programación y aplicaciones populares en Arduino como Java, Processing, Python, Mathematica, Matlab, Perl, Visual Basic, etc. Esto es posible debido a que Arduino se comunica mediante la transmisión de datos en formato serie que es algo que la mayoría de los lenguajes anteriormente citados soportan. Para los que no soportan el formato serie de forma nativa, es posible utilizar software intermediario que traduzca los mensajes enviados por ambas partes para permitir una comunicación fluida. Es bastante interesante tener la posibilidad de interactuar con Arduino mediante esta gran variedad de sistemas y lenguajes puesto que dependiendo de cuales sean las necesidades del problema que se va a resolver podremos aprovecharnos de la gran compatibilidad de comunicación que ofrece. El entorno de desarrollo de Arduino es sencillo e intuitivo además puede descargarse gratuitamente desde su página oficial para distintos sistemas operativos. Ha sido implementado con Processing, un lenguaje similar a Java. Su última versión es la 1.5.3. Está formado por una serie de menús, una barra de herramientas con botones para las funciones comunes, un editor de texto donde escribiremos el código, un área de mensajes y una consola de texto. En la figura 6.3 se puede apreciar la composición del software de Arduino.
F igur a 6.3. Interfaz del software de Arduino.
12
Estancias II 2013 A continuación se comentara la utilidad de cada área del programa centrándonos solo en lo importante. Menú
La parte más importante se encuentra en Herramientas. Desde aquí se puede configurar el programa para que pueda comunicarse con la placa Arduino. Pasando el ratón por Tarjeta aparecerá una lista con los tipos de placa Arduino que el programa comprende. Aquí se selecciona Arduino Uno dependiendo de con cual estemos trabajando. En el campo Puerto Serial se selecciona el que corresponda a la placa que se conectara mediante USB. Si se utiliza Windows el puerto tendrá un nombre del estilo COMx pero en Linux será /dev/ttyUSBx donde x es un número. En caso de que aparezcan varios puertos serie y no se reconozca cual es el de la placa se procedera a desconectarla, se anotan los puertos que aparecen, se reconecta la placa y se vuelve a mirar la lista de puertos. El nuevo puerto que haya aparecido será el de la placa. Botones comunes
Estos botones son accesos rápidos a ciertas acciones que también están disponibles mediante el menú. Los botones son los siguientes:
Verificar: Comprueba y compila el código. Cargar: Además de compilar el código lo inyecta en la placa. Nuevo: Crea un nuevo sketch. Abrir: Abre un sketch previamente guardado. Guardar: Almacena en disco los cambios realizados en el sketch. Monitor Serial: Abre una nueva ventana desde la que se puede comunicar bidireccionalmente vía serie con la placa, es decir, es posible leer la información que envía o proporcionarla. La figura 6.4 muestra esta ventana.
F igur a 6.4. Ventana del monitor serie.
13
Estancias II 2013 Editor de texto
En este área se escribe la implementación (denominada por el programa sketch) para cargarla en la placa Arduino. El programa tiene 3 partes. La primera consiste en la inclusión de librerías y la declaración de constantes o variables globales que se pueden utilizar en cualquier función del programa. La segunda es el método setup() que es el encargado de inicializar los dispositivos conectados a la placa y será ejecutado solo al iniciar el sistema. La tercera parte consiste en el método loop() que ejecutará su código continuamente, es decir, en modo bucle. Aquí es donde se escribirá la lógica de la placa Arduino. Consola de texto
Aquí aparecerán con mayor detalle los eventos del área de mensajes. 6.2.2. Processing-2.0.2.
Processing es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java. La utilización de una interfaz en Processing facilita el uso del dispositivo porque permite manipular de manera sencilla el control de temperatura. En la figura 6.5 se muestra la interfaz de Processing.
F igur a 6.5. Interfaz del software Processing.
14
Estancias II 2013
7. DISPOSITIVOS COMPATIBLES CON ARDUINO. Para conseguir las características de un sistema domótico es necesario que además del órgano central que controle el sistema se tenga a disposición sensores que puedan recoger datos sobre la situación de cada habitación de la vivienda. Dependiendo de estos datos el sistema domótico debe ser capaz de comunicarse con los actuadores para mejorar la situación de la vivienda. También deben existir elementos con los que el usuario pueda comunicarse con el sistema y pueda hacer los cambios oportunos manualmente. Los dispositivos estarán conectados mediante cables o directamente acoplados a la placa Arduino. Algunos de ellos disponen de librerías que se deben adjuntar al programa para poder usar las utilidades que contengan. Para ello se añade la carpeta de la librería en la carpeta libraries del entorno de desarrollo de Arduino. Al principio del código del sketch s incluye la librería con la línea: #include Para utilizar los métodos de sensores y actuadores digitales es necesario tener en cuenta que solo se tienen dos posibles valores, HIGH representa el nivel alto y LOW el nivel bajo. En el caso de los analógicos su uso es levemente más complejo pero también más configurable ya que tiene que leerse/escribir un voltaje de 0 a 5 voltios que se representa en 10 bits (lectura) o en 8 bits (escritura), es decir la tensión puede tener 1024 (lectura) o 256 (escritura) valores distintos. 7.1. Sensores.
Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas, llamadas variables de instrumentación, y transformarlas en variables eléctricas. Las variables de instrumentación pueden ser por ejemplo: temperatura, intensidad lumínica, distancia, aceleración, inclinación, desplazamiento, presión, fuerza, torsión, humedad, movimiento, pH, etc. Una magnitud eléctrica puede ser una resistencia eléctrica (como en un detector de temperatura resistivo), una capacidad eléctrica (como en un sensor de humedad), una tensión eléctrica (como en un termopar), una corriente eléctrica (como en un fototransistor), etc. Los sensores siempre que estén activados estarán tomando continuamente la situación actual de una habitación y es el servidor o la placa Arduino quien leerá esta información y decidirá cómo actuar. Pueden ser digitales o analógicos. Los digitales tienen que ser inicializados como pin de salida con el método pinMode(numeroDePin, OUTPUT). Para poder obtener una lectura de los datos se usa el método digitalRead(numeroDePin). Los analógicos no requieren esta fase de inicio y para leer lo se hace con analogRead(numeroDePin). Es recomendable asignar a una variable la 15
Estancias II 2013 lectura recibida por los métodos para evitar tener que llamar a la misma función en caso de necesitarse de nuevo. Como los sensores analógicos son algo más complejos que los digitales se tratarán con un ejemplo. Los sensores que sean responsables de la seguridad de la vivienda deberían avisar del evento mediante un actuador (por ejemplo un timbre o LED) o algún elemento de comunicación (como un correo electrónico o un mensaje de texto al móvil). También podría almacenarse el suceso en un fichero del servidor. A continuación se describirán algunos sensores a tener en cuenta en un sistema domótico. Módulo de gas
El detector de gas hace que la vivienda gane en seguridad si cuando detecta un nivel alto de gas (lectura HIGH) el sistema avisa a la persona. Sería importante que el sistema pudiera desconectar la mayor parte de red eléctrica posible de la vivienda.
F igur a 7.1. Sensor de gas.
Módulo PIR
Otro elemento que interviene en la seguridad cuando no hay nadie en casa es un detector de movimiento. En caso de detectar suficiente movimiento se leerá un nivel alto. También se puede utilizar para el confort del ser humano. En caso de detectar movimiento en la habitación encender por ejemplo las luces o la calefacción, dependiendo también de la lectura responsable de los dos casos.
F igur a 7.2. Sensor de movimiento.
16
Estancias II 2013 Módulo de luz
Este dispositivo es capaz de detectar el nivel de intensidad de luz que hay en la habitación de forma analógica. El sistema leerá el voltaje y en caso de detectar un nivel bajo de luz podría encender las luces de la habitación siempre y cuando se detecte movimiento.
F igura 7.3. Sensor de luz.
Módulo de humedad (y temperatura)
Algunos dispositivos son capaces de obtener varias mediciones en el mismo módulo. El módulo de la figura 7.4 corresponde a un DHT11 capaz de representar digitalmente la humedad ambiental medida en % además de la temperatura en Cº. Tiene una precisión decimal y dispone de su propia librería que contiene los métodos para recoger sus mediciones. Este módulo es interesante colocarlo en la zona externa de la casa, como el balcón, la galería o el jardín.
F igura 7.4. Sensor de humedad y temperatura (DHT11).
Módulo de temperatura
En caso de utilizar calefacción o aire acondicionado el sensor de temperatura puede ayudar a reducir el coste de la factura de la luz y acomodar un poco más al ser humano. Cuando se detecte cierto umbral de temperatura podría apagarse/encender o modificar la potencia de la calefacción. La figura 7.5 muestra un termistor analógico, es decir, un sensor resistivo de temperatura.
17
Estancias II 2013 Su funcionamiento se basa en la variación de la resistividad que presenta un semiconductor con la temperatura.
F igur a 7.5. Sensor de temperatura.
7.2. Actuadores.
Un actuador es un dispositivo capaz de transformar energía (en nuestro caso eléctrica) en la activación de un proceso con la finalidad de generar un efecto sobre un proceso automatizado. Su función en un sistema domótico va a ser la de cambiar la situación de la vivienda tras un evento ocasionado al hacer por ejemplo una lectura de un sensor que debe ser tratada. Módulo Relevador
Funciona como un interruptor controlado por un circuito eléctrico en el que, por medio de una bobina y un electroimán, se acciona un juego de uno o varios contactos que permiten abrir o cerrar otros circuitos eléctricos independientes. Este tipo de módulos permite activar actuadores como por ejemplo el de una persiana, la puerta del garaje o el de una bombilla.
F igura 7.6. Relevador.
7.3. Interfaz.
Su principal objetivo es ofrecer comunicación entre el sistema y el ser humano. Consisten en elementos visuales/auditivos que avisan de eventos o táctiles para poder causarlos.
18
Estancias II 2013 Módulo LED
La función de este dispositivo es avisar mediante un diodo emisor de luz la ocurrencia de un evento que puede requerir su atención. Pueden utilizarse de forma digital (encendido/apagado) o de forma analógica si se quiere variar la intensidad de la luz.
F igur a 7.7. Módulo LED.
Módulo timbre
Este elemento es capaz de producir sonidos. Módulo interesante para avisar al ser humano sobre un problema grave en la vivienda dado que la sensibilidad auditiva es mayor que la visual.
F igur a 7.8. Módulo de timbre.
Módulo pulsable
Para comunicarse con el sistema y crear eventos es posible utilizar teclados o botones. Por ejemplo la función de un botón presionado al salir de casa podría ser apagar luces, calefacción y activar el sistema de seguridad.
F igur a 7.9. Teclado y botón.
19
Estancias II 2013 Módulo visualizador
Con él se pude conocer la situación de la vivienda y de la ocurrencia de eventos que nos envíe el sistema en forma de texto sobre una pantalla.
F igur a 7.10. Pantalla LCD.
7.4. Comunicadores.
Este apartado abarca el conjunto de elementos que permiten la comunicación entre distintas placas Arduino y el servidor o incluso con electrodomésticos del hogar. El medio por el que circula la información puede ser por aire (modulación de ondas electromagnéticas) o físico (por cable) teniendo sus ventajas e inconvenientes. Normalmente estos dispositivos tendrán a disposición librerías con funciones ya implementadas que facilitaran su manejo. Si el medio es el aire el sistema total va a ser más barato puesto que se evita tener que cablear las habitaciones, además de esto se logra que sean más estéticas. En cambio las transmisiones son menos seguras y puede haber problemas por el ruido ocasionado de otros elementos que utilizan el aire como forma de comunicación. Además los obstáculos que haya entre emisor y receptor van a reducir la distancia de transmisión. Por parte de los sistemas que utilizan cables para enviar datos debemos tener en cuenta su coste de instalación además de estudiar si se prefiere estéticamente ese cableado en la habitación. Pero esto puede suplirse sabiendo que las transmisiones serán más robustas y seguras. Módulo Wi-Fi
Si se desea utilizar el protocolo TCP/IP pero se quiere evitar tener que cablear la habitación se puede utilizar este módulo también acoplable a la Arduino. Aunque utiliza otra librería los métodos son equivalentes al del módulo Ethernet. La frecuencia de la señal ronda los 2.4GHz.
F igur a 7.11. WiFi Shield.
20
Estancias II 2013 Módulo XBee
Este elemento se comunica de forma inalámbrica utilizando ZigBee que es un conjunto de protocolos de alto nivel de comunicación inalámbrica para su utilización con radiodifusión digital de bajo consumo. Su objetivo son las aplicaciones que requieren comunicaciones seguras con baja tasa de envío de datos y que necesiten un bajo consume. Utiliza unas frecuencias comprendidas entre 865MHz y 2.4GHz.
F igur a 7.12. Módulo XBee.
Módulo Bluetooth
Se denomina Bluetooth al protocolo de comunicaciones diseñado especialmente para dispositivos de bajo consumo, que requieren corto alcance de emisión y basados en transceptores de bajo costo. Opera mediante un enlace por radiofrecuencia en la banda ISM de los 2,4 GHz. Su uso es adecuado cuando puede haber dos o más dispositivos en un área reducida sin grandes necesidades de ancho de banda. Bluetooth tiene la ventaja de simplificar el descubrimiento y configuración de los dispositivos, ya que éstos pueden indicar a otros los servicios que ofrecen, lo que redunda en la accesibilidad de los mismos sin un control explícito de direcciones de red, permisos y otros aspectos típicos de redes tradicionales. El WiFi utiliza el mismo espectro de frecuencia que Bluetooth con una potencia de salida mayor que lleva a conexiones más sólidas.
F igur a 7.13. Módulo Bluetooth.
21
Estancias II 2013 Módulo infrarrojo
Otra forma de comunicación sin medio físico es la utilización de rayos infrarrojos. Este tipo de comunicación consigue tener menos interferencias debido a la mayor frecuencia del espectro electromagnético en la que trabaja. Normalmente no es un método de comunicación entre placas Arduino sino que es utilizado para contactar con los electrodomésticos del hogar.
F igur a 7.14. Emisor y receptor infrarrojo.
Puerto Serie
Un puerto serie o puerto serial es una interfaz de comunicaciones de datos digitales, frecuentemente utilizado por computadores y periféricos, donde la información es transmitida bit a bit enviando un solo bit a la vez, en contraste con el puerto paralelo que envía varios bits simultáneamente. Es otro método de comunicación cableada que se puede usar para la comunicación entre un PC y una placa, o entre placas. El puerto serie consiste en un canal de recepción y otro de transmisión haciendo que el punto de recepción de un dispositivo esté conectado con el de transmisión del otro dispositivo. Todas las placas Arduino disponen de al menos un puerto serie compuesto por los pines digitales 0(rx) y 1(tx). Al conectar un cable de USB de la placa al ordenador estaremos aprovechando este puerto serie en el que se debe configurar la velocidad de datos en bits por segundo (baudios) para la transmisión de datos. Para iniciar el puerto serie y establecer los baudios utilizaremos la función begin(speed) de la librería Serial . Se recomienda establecer el puerto serie a 9600 baudios. Esta fase se hace en la función de configuración de la placa setup(). La placa Arduino tiene un buffer de recepción de datos de 128 bytes. Con la función available() podremos conocer cuántos caracteres (bytes) hay disponibles en el buffer. En caso de que haya datos en el buffer la función read() devolverá el primer carácter (byte) guardado en el puerto serie y lo retirará del buffer. En caso de que no haya datos devolverá un -1. Es posible crear nuevos puertos serie con la librería SoftwareSerial.h en la que se tiene que especificar los pines de recepción y transmisión de datos.
22
Estancias II 2013
8. PROTOTIPO DE INTERFAZ DOMÓTICA. En este punto se propondrá un modelo sencillo de interfaz domótico utilizando Processing. Se comentarán el código utilizado para su mejor entendimiento. 8.1. Diseño de la interfaz.
Se optó por realizar la interfaz en Processing debido a que es un software libre, además de que es sencillo hacer la comunicación con el Arduino. La interfaz se divido en secciones para facilitar su utilización. Dichas secciones son las siguientes: Inicio: En esta parte se describe que trata dicha interfaz, aquí se despliega un cuadro de texto con una bienvenida, en la figura 8.1 se observa la interfaz (la parte de presentación).
F igur a 8.1. Inicio: Bienvenida en la interfaz de Processing.
Focos: En esta parte se ubica el control de la intensidad de los focos hasta que estén totalmente apagados o encendidos. Dichos focos pertenecen al Cuarto 1, Cuarto 2, Cuarto 3, sala, cocina, baño. En la figura 8.2 se observa la sección mencionada.
23
Estancias II 2013
F igur a 8.2. Control de la intensidad de los focos.
Control de temperatura: En esta sección se encuentra un pequeño control de la temperatura variándola de 0 a 100%, el aumento o disminución de la temperatura se realiza mediante las teclas w (aumentar) y s (disminuir). Al aumentar o disminuir la temperatura se muestra una barra de color verde para visualizar mejor el control de la temperatura. En la figura 8.3 se muestra la sección del control de temperatura con la cual el usuario puede interactuar de manera sencilla.
24
Estancias II 2013
F igur a 8.3. Control de temperatura.
Cámara: En esta parte se puede visualizar el entorno mediante un dispositivo de cámara web montado en puntos específicos de la casa para facilitar el estarse trasladando por toda la casa para observar que sucede en cada sección, también se utiliza para mejorar la seguridad de la casa. En la figura 8.4 se muestra la parte de la cámara web.
F igur a 8.4. Visualización de la cámara web.
25
Estancias II 2013 8.2. Código de la interfaz en Processing.
En esta sección se muestra el código utilizado para realizar la interfaz en Processing y también la comunicación con Arduino. Se utilizó la librería de Arduino en Processing para poder hacer la comunicación entre ambos. A continuación se muestra el código realizado dicho código se anexa a la carpeta del proyecto con el nombre de Interfaz_casa_domotica. /** * ControlP5 Tab * */ import processing.serial.*; import cc.arduino.*; Arduino arduino; int ledPin=9; int potPin=0; import controlP5.*; import processing.video.*; Capture cam; ControlP5 cp5; int val; //size(200,200); int variableus; int temp = 0; int valortemp=0; float radio=0; float x=0; float y=0; float angulo = 0; float R=100; int cuarto1 = 0; int cuarto2 = 0; int cuarto3 = 0; int sala = 0; int cocina = 0; int bano = 0; boolean Inicio = false; Knob myKnobB; PImage img; Textlabel myTextlabelA; Textlabel myTextlabelB; Textarea myTextarea; void setup() { arduino = new Arduino(this, Arduino.list()[0], 57600); arduino.pinMode(ledPin, Arduino.OUTPUT); size(600,500);
26
Estancias II 2013 noStroke(); cam = new Capture(this); cam.start(); // The image file must be in the data folder of the current sketch // to load successfully img = loadImage("Imagen2.jpg"); // Load the image into the program cp5 = new ControlP5(this); // By default all controllers are stored inside Tab 'default' // add a second tab with name 'extra' // if you want to receive a controlEvent when // a tab is clicked, use activeEvent(true) cp5.getTab("default") .activateEvent(true) .setLabel("INICIO") .setId(1) ; cp5.getTab("FOCOS") .activateEvent(true) .setId(2) ; cp5.getTab("TEMPERATURA") .activateEvent(true) .setId(3) ; cp5.getTab("CAMARA") .activateEvent(true) .setId(4) ; // create a few controllers myTextlabelA = cp5.addTextlabel("label") .setText("(aplicación para personas con discapacidad motriz).") .setPosition(270,30) .setColorValue(0xffffff00) .setFont(createFont("Georgia",14)) ; myTextlabelA = cp5.addTextlabel("label2") .setText("DOMÓTICA") .setPosition(230,3) .setColorValue(0xffffff00) .setFont(createFont("Georgia",25)) ; myTextlabelB = cp5.addTextlabel("label3") .setText("¡BIENVENIDO!") .setPosition(200,100) .setColorValue(0xffffffff) .setFont(createFont("Georgia",25)) ;
27
Estancias II 2013 myTextlabelB = cp5.addTextlabel("label4") .setText("----------------------------------------FOCOS----------------------------------------") .setPosition(30,60) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label5") .setText("---------------------CONTROLES: INTENSIDAD DE LA LUZ---------------------") .setPosition(30,200) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label6") .setText("Cuarto1") .setPosition(30,100) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label7") .setText("Cuarto2") .setPosition(30,150) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label8") .setText("Cuarto3") .setPosition(220,100) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label9") .setText("Sala") .setPosition(240,150) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label10") .setText("Cocina") .setPosition(400,100) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label11") .setText("Baño") .setPosition(410,150) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label12") .setText("-------------------------CONTROL DE TEMPERATURA-------------------------") .setPosition(30,80) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label13")
28
Estancias II 2013 .setText("PRESIONE LAS TECLAS 'W' Y 'S' PARA") .setPosition(300,150) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label14") .setText("CAMBIAR LA TEMPERATURA:") .setPosition(300,170) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label15") .setText("W-------> AUMENTAR TEMPERATURA") .setPosition(300,190) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextlabelB = cp5.addTextlabel("label16") .setText("S-------> DISMINUIR TEMPERATURA") .setPosition(300,210) .setColorValue(0xffffffff) .setFont(createFont("Georgia",15)) ; myTextarea = cp5.addTextarea("txt") .setPosition(150,150) .setSize(200,200) .setFont(createFont("arial",12)) .setLineHeight(14) .setColor(color(128)) .setColorBackground(color(255,100)) .setColorForeground(color(255,100)); ; myTextarea.setText("La domótica es la automatización y control centralizado y/o remoto" +" de aparatos o sistemas eléctricos o electrónicos en la vivienda." +" Los objetivos principales de la domótica es aumentar el confort, ahorrar" +" energía y mejorar la seguridad." +" ...................................................................." +" Home automation is the automation and centralized control and / or " +" remote devices and electrical and electrical systems in the home." +" The main objectives of home automation is to increase comfort," +" save energy and improve safety." ); cp5.addSlider("expandirCuadro") .setRange(100,400) .setValue(200) .setPosition(180,400) .setSize(100,19) ; myKnobB = cp5.addKnob("cuarto2") .setRange(0,255) .setValue(0) .setPosition(70,360) .setRadius(50)
29
Estancias II 2013 .setNumberOfTickMarks(10) .setTickMarkLength(4) .snapToTickMarks(true) .setDragDirection(Knob.HORIZONTAL) ; myKnobB = cp5.addKnob("cuarto1") .setRange(0,255) .setValue(0) .setPosition(70,230) .setRadius(50) .setNumberOfTickMarks(10) .setTickMarkLength(4) .snapToTickMarks(true) .setDragDirection(Knob.HORIZONTAL) ; myKnobB = cp5.addKnob("sala") .setRange(0,255) .setValue(0) .setPosition(250,360) .setRadius(50) .setNumberOfTickMarks(10) .setTickMarkLength(4) .snapToTickMarks(true) .setDragDirection(Knob.HORIZONTAL) ; myKnobB = cp5.addKnob("cuarto3") .setRange(0,255) .setValue(0) .setPosition(250,230) .setRadius(50) .setNumberOfTickMarks(10) .setTickMarkLength(4) .snapToTickMarks(true) .setDragDirection(Knob.HORIZONTAL) ; myKnobB = cp5.addKnob("bano") .setRange(0,255) .setValue(0) .setPosition(430,360) .setRadius(50) .setNumberOfTickMarks(10) .setTickMarkLength(4) .snapToTickMarks(true) .setDragDirection(Knob.HORIZONTAL) ; myKnobB = cp5.addKnob("cocina") .setRange(0,255) .setValue(0) .setPosition(430,230) .setRadius(50) .setNumberOfTickMarks(10)
30
Estancias II 2013 .setTickMarkLength(4) .snapToTickMarks(true) .setDragDirection(Knob.HORIZONTAL) ; // create a toggle cp5.addToggle("Inicio") .setPosition(40,70) .setSize(50,20) ; // arrange controller in separate tabs cp5.getController("label").moveTo("global"); cp5.getController("label2").moveTo("global"); cp5.getController("label3").moveTo("default"); cp5.getController("expandirCuadro").moveTo("default"); cp5.getController("cuarto1").moveTo("FOCOS"); cp5.getController("cuarto2").moveTo("FOCOS"); cp5.getController("cuarto3").moveTo("FOCOS"); cp5.getController("sala").moveTo("FOCOS"); cp5.getController("cocina").moveTo("FOCOS"); cp5.getController("bano").moveTo("FOCOS"); cp5.getController("label4").moveTo("FOCOS"); cp5.getController("label5").moveTo("FOCOS"); cp5.getController("label6").moveTo("FOCOS"); cp5.getController("label7").moveTo("FOCOS"); cp5.getController("label8").moveTo("FOCOS"); cp5.getController("label9").moveTo("FOCOS"); cp5.getController("label10").moveTo("FOCOS"); cp5.getController("label11").moveTo("FOCOS"); cp5.getController("label12").moveTo("TEMPERATURA"); cp5.getController("label13").moveTo("TEMPERATURA"); cp5.getController("label14").moveTo("TEMPERATURA"); cp5.getController("label15").moveTo("TEMPERATURA"); cp5.getController("label16").moveTo("TEMPERATURA"); cp5.getController("Inicio").moveTo("CAMARA"); // Tab 'global' is a tab that lies on top of any // other tab and is always visible } void draw() { background(0); // Displays the image at its actual size at point (0,0) image(img, 0, 0); textAlign(RIGHT); valortemp=temp*(1); arduino.analogWrite(ledPin, val); //variableus=valortemp/2.5; text(valortemp/2.5,100,400); fill(cuarto1); ellipse(120,110,30,30); fill(cuarto2);
31
Estancias II 2013 ellipse(120,160,30,30); fill(cuarto3); ellipse(300,110,30,30); fill(sala); ellipse(300,160,30,30); fill(cocina); ellipse(480,110,30,30); fill(bano); ellipse(480,160,30,30); if(Inicio==true) { if (cam.available()) { cam.read(); } image(cam, 0, 0); } //rect(temp,4,10,10);
fill (131,245,12); //fill (255,0,0); //fill (255,255,255); rect(150,400,( 80),temp*(-1)); fill(0,255,255); noStroke(); radio = temp + 0.5; ///////////////////////////// val =valortemp; //arduino.analogWrite(ledPin, val); ////////////////////////////////// //fill(0,5); //rect (0,0,width,height); //noStroke(); } void expandirCuadro(int theValue) { myTextarea.setWidth(theValue); } void controlEvent(ControlEvent theControlEvent) { if (theControlEvent.isTab()) { println("got an event from tab : "+theControlEvent.getTab().getName()+" "+theControlEvent.getTab().getId()); } }
with
id
void keyPressed() { switch(key) { case('1'):myKnobB.setConstrained(false).hideTickMarks().snapToTickMarks(false);break; case('2'):myKnobB.shuffle();break; }
32
Estancias II 2013 if(key=='s'||key=='s'){ temp--; if (temp<0){ temp=0; } }else if(key=='w'||key=='w'){ temp++; if (temp>250) { temp=250; } } }
Los botones de la interfaz se realizaron mediante la librería llamada ControlP5, esto se hizo con el fin de facilitar la realización de la interfaz, además de que la interfaz queda más estética.
9. CONEXIONES FÍSICAS. En esta parte se mostraran las conexiones físicas que se realizaron para demostrar que el sistema domótico funciona. Debido a que existen limitaciones en cuanto al presupuesto, solo se realizaron pruebas con algunos sensores. 9.1. Encendido y apagado de las luces.
Los transistores a utilizados son tipo MOSFET cuya velocidad de conmutación es superior a la demás familia de transistores. El MOSFET utilizado es el IRF640, debido a que cuenta con las características adecuadas para la aplicación que se le dará. El MOSFET IRF640 se elige por su capacidad de manejar un alto voltaje y corriente, lo que da la posibilidad de utilizar este circuito para proyectos o aplicaciones de requerimientos eléctricos superiores, agregándole cierta flexibilidad al sistema. Se utilizó una fuente de alimentación de una computadora de escritorio para alimentar el MOSFET. Las derivaciones que se utilizaron fueron: una de 12v para el MOSFET y una de 5V para el Optocoplador. En la figura 9.1 se observa el diseño del circuito en el programa Proteus.
33
Estancias II 2013
F igur a 9.1. Circuito del control de temperatura diseñado en la plataforma Proteus.
El circuito fue pasado a una tablilla de conexiones para posteriormente realizar la comunicación Processing-Arduino. En la figura 9.2 se observa la conexión del circuito con Arduino y este a su vez conectado vía puerto USB a la computadora para que el usuario pueda interactuar por medio de la interfaz diseñada en Processing.
F igur a 9.2. Circuito del control de temperatura utilizando la librería Processing-Arduino.
Para simular el encendido y apagado de las luces de cada habitación se han utilizado leds. En caso de querer hacerlo más real puede sustituirse el led por un relé y una bombilla. Por parte del comedor aprovechamos el led integrado en la placa (pin 13). En la figura 9.3 se observa un osciloscopio donde se puede ver el ancho de pulso para variar la intensidad del foco.
34
Estancias II 2013
F igur a 9.3. Variación de la intensidad del foco mediante Processing-Arduino.
9.2. Control de temperatura.
En la parte del sensor de temperatura, para conectarlo al Arduino, en este caso se ha usado un cable que contiene tres hilos: uno rojo que va al SIG (datos), otro blanco que va al VCC (alimentación) y otro negro que va al GND (masa). El conector NC no se usa por lo que no necesita cable. Es importante tener bien identificado cada hilo para conectarlo en su pin correspondiente del Arduino. En la parte del Arduino UNO se conecta el cable rojo (SIG) al pin A0 analógico. El cable blanco (VCC) se conecta al ping 5V, el de alimentación. Y el cable negro (GND) va conectado a cualquier de los pines GND del Arduino. El sensor de temperatura y humedad conectado al Arduino UNO quedará como se muestra en la figura 9.4.
F igur a 9.4. Conexión del sensor de humedad-temperatura a la placa Arduino.
35
Estancias II 2013
10. RESULTADOS. Como resultados se tiene hasta el momento un control de temperatura y un control de encendido y apagado de focos que cuenta con una interfaz realizada en Processing y mandando datos a través del Arduino para variar el calor de salida o aumentar y disminuir la intensidad de un foco o resistencia eléctrica. En la figura 10.1 se observa el sistema de variación de la intensidad de la luz de un foco de 12 V simulando los focos de los cuartos de la vivienda.
F igur a 10.1. Variación de la intensidad de un foco mediante la placa Arduino.
La variación de la luz del foco está controlada mediante un PWM realizado mediante programación en Processing. Mediante los controles de intensidad de los focos que se realizaron en la interfaz de Processing se varia el PWM con lo cual permite bajar o subir la intensidad de la luz del foco. Para el control de temperatura se tiene la lectura de la temperatura del cuarto mediante un sensor de temperatura conectado a la plataforma Arduino. Una vez que se conoce la temperatura del cuarto, se puede variar dicha temperatura mediante las teclas W y S para aumentar o disminuir la temperatura respectivamente. En la interfaz de Processing aparece una barra que se expande o contrae para poder visualizar mejor el control de la temperatura.
36
