Universidad Tecnológica de Puebla
Mecatrónica
Ingeniería en Tecnologías para la Automatización
Domótica
Jorge Cerezo Sánchez
Integrantes:
Verónica Valeria Méndez Meneses
Garcia Leal José Enrique
Reporte del área de Confort
01/12/15
ContenidoIntroducción.......................................................................................................................................2
Marco Teórico....................................................................................................................................4
Ethernet Shield...............................................................................................................................4
Comunicación TCP LabView...........................................................................................................6
Desarrollo...........................................................................................................................................8
Layout Confort...............................................................................................................................9
Lista de materiales.......................................................................................................................10
Lista de comandos........................................................................................................................10
LED´s RGB.....................................................................................................................................11
Persianas......................................................................................................................................22
Integración.......................................................................................................................................27
Hojas Técnicas..................................................................................................................................28
UNL2003.......................................................................................................................................28
TIP120..........................................................................................................................................29
MOC3011.....................................................................................................................................30
MAC12..........................................................................................................................................31
Introducción
¿Qué es Domótica?
La domótica es 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, que aporta seguridad y confort, además de comunicación entre el usuario y el sistema.
Un sistema domótico es capaz de recoger información proveniente de unos sensores o entradas, procesarla y emitir órdenes a unos actuadores o salidas. El sistema puede acceder a redes exteriores de comunicación o información.
La domótica permite dar respuesta a los requerimientos que plantean estos cambios sociales y las nuevas tendencias de nuestra forma de vida, facilitando el diseño de casas y hogares más humanos, más personales, poli funcionales y flexibles.
El sector de la domótica ha evolucionado considerablemente en los últimos años, y en la actualidad ofrece una oferta más consolidada. Hoy en día, la domótica aporta soluciones dirigidas a todo tipo de viviendas, incluidas las construcciones de vivienda oficial protegida. Además, se ofrecen más funcionalidades por menos dinero, más variedad de producto, que gracias a la evolución tecnológica, son más fáciles de usar y de instalar. En definitiva, la oferta es mejor y de mayor calidad, y su utilización es ahora más intuitiva y perfectamente manejable por cualquier usuario. Paralelamente, los instaladores de domótica han incrementado su nivel de formación y los modelos de implantación se han perfeccionado. Asimismo, los
servicios posventa garantizan el perfecto mantenimiento de todos los sistemas. En definitiva, la domótica de hoy contribuye a aumentar la calidad de vida, hace más versátil la distribución de la casa, cambia las condiciones ambientales creando diferentes escenas predefinidas, y consigue que la vivienda sea más funcional al permitir desarrollar facetas domésticas, profesionales, y de ocio bajo un mismo techo.
La red de control del sistema domótico se integra con la red de energía eléctrica y se coordina con el resto de redes con las que tenga relación: telefonía, televisión, y tecnologías de la información, cumpliendo con las reglas de instalación aplicables a cada una de ellas. Las distintas redes coexisten en la instalación de una vivienda o edificio. La instalación interior eléctrica y la red de control del sistema domótico están reguladas por el Reglamento Electrotécnico para Baja Tensión (REBT). En particular, la red de control del sistema domótico está regulada por la instrucción ITC-BT-51 Instalaciones de sistemas de automatización, gestión técnica de la energía y seguridad para viviendas y edificios.
Para esta materia el docente nos dio la tarea de desarrollar un sistema domótico totalmente funcional, para lo cual dividió al grupo en 6 equipos para cubrir cada área de la cual se conforma este sistema.
Marco TeóricoEthernet Shield
The Shield Ethernet Arduino conecta tu Arduino a Internet en cuestión de minutos. Sólo tiene que conectar este módulo en su placa Arduino, conectarlo a su red con un RJ45 cable (no incluido) y seguir algunas instrucciones sencillas para empezar a controlar su mundo a través de internet. Como siempre con Arduino, todos los elementos de la plataforma - hardware, software y documentación - es de libre acceso y de fuente abierta. Esto significa que usted puede aprender exactamente cómo se hace y utilice su diseño como punto de partida para sus propios circuitos.
Requiere una placa Arduino (no incluido)
5V Tensión de funcionamiento (suministrado por la Junta Arduino)
Ethernet Controller: W5100 con buffer interno 16K
La velocidad de conexión: 10 / 100Mb
Conexión con Arduino en el puerto SPI
Descripción
La Arduino Ethernet Shield permite a una placa Arduino para conectarse a internet. Se basa en la Wiznet W5100 chip de ethernet (hoja de datos). El Wiznet W5100 ofrece una red (IP) apilar capaz de TCP y UDP. Soporta hasta cuatro conexiones de socket simultáneas. Utilice la biblioteca de Ethernet para escribir bocetos que se conectan a Internet a través del escudo. El escudo de Ethernet se conecta a una placa Arduino usando largas cabeceras wire-wrap que se extienden a través del escudo. Esto mantiene la disposición de las clavijas intacto y permite que otro escudo para ser apilados en la parte superior.
La revisión más reciente de la Junta expone el pinout 1.0 en rev 3 de la placa Arduino UNO.
The Shield Ethernet tiene una conexión RJ-45 estándar, con un transformador de línea integrado y Power over Ethernet habilitado.
Hay una ranura para tarjetas micro-SD a bordo, que se puede utilizar para almacenar archivos para servir a través de la red. Es compatible con todas las placas Arduino / Genuino. El lector de tarjetas micro SD de a bordo es accesible a través de la Biblioteca SD. Cuando se trabaja con esta biblioteca, SS es el Pin 4. La revisión original del escudo contiene una ranura para tarjetas SD de tamaño completo; esto no es compatible.
El escudo también incluye un controlador de reajuste, para asegurar que el módulo Ethernet W5100 se restablece correctamente en el encendido. Las revisiones anteriores del escudo no eran compatibles con el Mega y la necesidad de restablecer manualmente después del encendido.
El escudo actual tiene un Power over Ethernet (PoE módulo) diseñado para extraer energía de un cable Ethernet de par trenzado de categoría 5 convencional:
IEEE802 .3af compatible
Ondulación baja producción y el ruido (100mVpp)
Entrada rango de voltaje de 36V a 57V
Sobrecarga y corto circuito de protección
9V de salida
Alta eficiencia convertidor DC / DC: typ 75% @ 50% de carga
Aislamiento 1500V (entrada a la salida)
Comunicación TCP LabView
Establecer una comunicación de red utilizando los protocolos TCP/IP usando el labview 7 espress se logra gracias a los vis para comunicación en red que nos ofrece este ambiente de desarrollo de programación gráfica orientado a la instrumentación.
Una comunicación de red que use TCP/IP el cual es un protocolo orientado a conexión y con control de errores que garantiza la integridad de la información es ideal para aplicaciones de automatización y control, esto unido al entorno de desarrollo ofrecido por el LabView nos da una poderosa herramienta para el diseño de sistema de control y monitoreo remoto tales como las redes SCADA.
Para comenzar, en primera estancia para realizar una comunicación TCP/IP deben existir al menos dos estaciones que van a realizar la comunicación, una estación pasiva la cual espera por una conexión entrante y una estación activa la cual inicia la comunicación realizando una llamada al número IP y puerto de la estación pasiva, veamos a continuación como se logra esta comunicación con LabView.
Estación activa
Como se dijo anteriormente la diferencia entre la estación activa y la pasiva es que la pasiva espera por una conexión entrante mientras la activa inicia una comunicación llamando a una estación pasiva usando el numero IP y puerto de la estación con la cual se quiere realizar la comunicación, el bloque principal que hace a una estación activa es TCP Open Conection el cual se puede encontrar en All functions -> Comunicación -> TCP y cuyo icono se muestra a continuación.
Open Connection
Por medio de la entrada address se configura la dirección IP de la estación o dispositivo al cual se esta llamando y la entrada remote port establece el puerto por el cual se realizara la conexión, la entrada time out mide el tiempo limite para
que una estación pasiva conteste, finalmente tenemos las salidas error out y connection ID que tienen las mismas funciones que para el bloque TCP Listen.vi
Write Bloques para leer y escribir
Una vez establecida la conexión los datos pueden fluir de la estación pasiva a la activa o al revés este flujo de información se controla con los bloques TCP Read y TCP Write para recibir y enviar datos, específicamente por medio del bloque TCP Write se envían datos de una estación a otra.
Los conectores principales de TCP Write son: Connection ID el cual debe ir cableado a la salida con el mismo nombre del bloque TCP Listen o TCP Open Connection con el cual se inició la comunicación para que se indique cual conexión se deben utilizar para enviar los datos, por la entrada data in se ingresa la cadena de caracteres que se desee enviar, timeout ms vigila que no se exceda el tiempo máximo que puede transcurrir mientras la otra estación recibe los datos, en caso de que este tiempo se exceda la salida error out generará un mensaje de error, la salida bytes written indica cuantos bytes se han enviado satisfactoriamente.
TCP Read tiene como función recibir datos enviados desde otra estación, sus principales conectores son: Connection ID el cual al igual que en TCP Write debe ir cableado a la salida del mismo nombre del bloque TCP Listen o TCP Open Connection con el cual se inició la comunicación para que se indique cual conexión se debe usar para recibir los datos, en la entrada bytes to read se programa el número de bytes que se está esperando en esta recepción, timeout ms al igual que en los vi anteriormente explicados tiene como función permitir establecer el tiempo máximo que se esperará para que se realice la operación de recepción de datos, error out reporta los errores ocurridos durante esta operación, la salida data out retorna los bytes recibidos dependiendo del valor de la entrada mode la cual establece uno de cuatro modos de operación.
Desarrollo
Nuestro equipo fue elegido para desarrollar el área de confort, lo cual consistió en el control de luces interiores, persianas y un sistema de riego.
Durante el periodo de la primera evaluación el docente nos explicó lo que consistía la domótica, como establecer una comunicación entre LabView y la tarjeta Arduino por medio de una Ethernet Shield.
Tarjeta Arduino con Ethernet Shield
Teniendo en claro estos puntos nos dieron la tarea de desarrollar el proyecto de un sistema domótico.
Teniendo un área ya determinada por equipo, la primera evaluación consistió en realizar un cronograma, layout, una tabla de comandos y una cotización del material que se necesitara para la realización del proyecto. A continuación se presentan todos estos puntos.
Layout Confort
En este layout se muestran todos los actuadores que se necesitarán para el proyecto así de cómo serán conectados para su correcto funcionamiento.
Lista de materiales.
Material CostosEthernet Shield 250
Fuente 12v 100NOC3010 20MAC12 30
Tira LED RGB 2M 210Bola de luces 100
TIP 120 50Aspersor de riego 50Motor reductor 150
total 960
Lista de comandos
Comando DescripciónQ Comando para un escenario
normal.W Comando para un escenario
para cine.U Comando para un escenario
romántico.S Comando par un escenario
modo fiesta.O Comando para apagar las
luces.? Activar el sistema de riego.
¿ Desactivar el sistema de riego.
LED´s RGB
Durante el segundo periodo del cuatrimestre se implementó el proyecto, en nuestra área lo primero que desarrollamos fue el control de los led´s RGB. Esto consistió en generar 6 escenarios para las posibles ocasiones que se puedan presentar, los cuales son:
Romántico Cine Fiesta Emergencia Cálido Apagado
Para ello tuvimos nuestro primer inconveniente, ya que este tipo de led´s solo funciona por medio de un ancho de pulso a 12V, pero nuestro Arduino solo da como salida un máximo de 5v. Investigando un poco encontramos que utilizando un UNL2003(arreglo de transistores tipo Darlington) nos daba el mismo ancho de pulso pero con el voltaje amplificado. Este tipo de integrados es generalmente utilizado para el control de motores paso a paso.
Amplificación de señal con ULN2003a
Este integrado nos dio la solución al problema, por lo que seguimos con la programación de los led´s, para esto hay que tomar encuentra lo que ya habían dicho antes, que estos solo funcionan con un ancho de pulso. Esto es así porqué de esta manera pueden generar diferentes tipos de colores.
Una tira de led ´s RGB tiene cuatro pines los cuales uno es para la alimentación directa a 12v, los otros tres son los pines para los tres colores primarios que son el Rojo (Red), Verde (Green) y el Azul (Blue), de ahí RGB por sus siglas en ingles.
Pines de la Tira RGB
En la programación con Arduino fue necesario utilizar los puertos de salida como salidas analógicas estas funcionan de la siguiente manera.
analogWrite(pin, value)
Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedimiento de modulación por ancho de pulso (PWM) a uno de los pines de Arduino marcados como PWM. El más reciente Arduino, que implementa el chip ATmega368, permite habilitar como salidas analógicas tipo PWM los pines 3, 5, 6, 9, 10 y 11. El valor que se puede enviar a estos pines de salida analógica puede darse en forma de variable o constante, pero siempre con un margen de 0-255.
analogWrite(pin, valor); // escribe 'valor' en el 'pin'
// definido como analógico
Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de 255 genera una salida de 5 voltios de salida en el pin especificado. Para valores de entre 0 y 255, el pin saca tensiones entre 0 y 5 voltios - cuanto mayor
sea el valor, más a menudo estará a HIGH (5 voltios). Teniendo en cuenta el concepto de señal PWM , por ejemplo, un valor de 64 equivaldrá a mantener 0 voltios de tres cuartas partes del tiempo y 5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida en 0 la mitad del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192 equivaldrá a mantener en la salida 0 voltios una cuarta parte del tiempo y de 5 voltios de tres cuartas partes del tiempo restante.
Teniendo claro esto para la programación, el siguiente paso a seguir es programar los tipos de colores que se desean, para esto hay que consultar una tabla de colores que nos generan los valores que se deben de insertar en el Arduino. La tabla es la que se presenta a continuación.
En esta tabla los colores que presentan la máxima saturación y la máxima luminosidad a la vez, son los que reúnen dos requisitos: al menos uno de los coeficientes es 255 y al menos uno de los coeficientes es 0.
También se pueden obtener estos valores desde la herramienta de Paint, solo dando click en la opción de “Editar Colores”, y solo movemos el cursor por la paleta de colores y se nos va mostrando los valores necesarios para generar ese color en la tira de led´s.
Sabiendo los valores que son necesarios para generar el color deseado, solo lo insertamos en el programa de Arduino
Como se requieren 5 escenarios para esta área, se realizó un programa para probar cada color, ya que algunos eran inestables en la tira de led´s y empezaban a parpadear.
Programa de Pruebas para la tira de LED´s RGB
Después de tener los colores que fueron asociados con cada tipo de escenario, integramos los 6 escenarios en un solo programa, y le agregamos las instrucciones para tener comunicación por medio del Ethernet Shield y así hacer pruebas con el programa Labview.
Para el escenario Fiesta se agregó una salida para la ejecución de la bola de luces. Para esto fue necesario un pequeño circuito el para que a partir de la señal digital emitida del Arduino energice la bola de luces.
Circuito Opto-acoplador
Este circuito es ideal para trabajar con corriente Alterna ya que nos ofrece una protección para el controlador, porque no se activa el transistor directamente
El programa para esta sección quedo de la siguiente manera.
#include <SPI.h>
#include <Ethernet.h>
const int rojo = 3;
const int verde = 5;
const int azul = 6;
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,77);
char Buffer[1024];
EthernetServer server(80);
void setup(){
Serial.begin(9600);
Ethernet.begin(mac, ip);
server.begin();
pinMode (7,OUTPUT);
pinMode(rojo,OUTPUT);
pinMode(verde,OUTPUT);
pinMode(azul,OUTPUT);
pinMode(2, OUTPUT);
pinMode(4, OUTPUT);
pinMode(8, INPUT);
pinMode(9, INPUT);
}
void loop() {
EthernetClient client = server.available();
int i=0;
if (client) {
while (client.available()) {
Buffer[i]=client.read();
Serial.print(Buffer[i]);
i++;
Buffer[i]='\0';}
//Modo romantico
if (Buffer[0] == 'U'){
analogWrite(rojo,255);//rojo
analogWrite(verde,128);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
}
//Modo cine
if (Buffer[0] == 'Q'){
analogWrite(rojo,0);//rojo
analogWrite(verde,46);//amarillo
analogWrite(azul,191);//celeste
digitalWrite(7, LOW);
}
//Modo fiesta
if (Buffer[0] == 'S'){
analogWrite(rojo,255);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,255);//celeste
digitalWrite(7, HIGH);
}
//Modo calido
if (Buffer[0] == 'W'){
analogWrite(rojo,0);//rojo
analogWrite(verde,153);//amarillo
analogWrite(azul,163);//celeste
digitalWrite(7, LOW);
}
//Modo emergencia
if (Buffer[0] == 'E'){
analogWrite(rojo,255);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
delay(500);
analogWrite(rojo,0);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
delay(500);
}
//Modo apagado
if (Buffer[0] == 'O'){
analogWrite(rojo,0);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
}
}
delay (100);
Buffer[0]='\0';
i=0;
}
Despues de esto se procedió a programar el VI para la comunicación por ethernet, el vi quedo de la siguiente manera.
Panel frontal del VI.
Aquí se muestran los controles para insertar la IP y el puerto del server asignado al Arduino, Los botones para seleccionar el escenario deseado y la cadena enviada al Arduino.
Diagrama de bloques del VI.
Este diagrama de bloque esta todas las funciones necesarias para la comunicación por Ethernet.
Primero se inicia con “TCP Open Conection” se le agregan controles para oner las dirección IP y el Puerto desde el panel frontal, después dentro de una estructura “While Loop” se inserta un “TCP write” el cual nos permitirá enviar el dato por la red TCP o Ethernet. Para determinar que dato enviar se hacen comparación por cada botón que representan los escenarios deseados y deja pasar un carácter si alguno se activa. La salida de cada comparación se introduce en un “Concatenate String” para que sea enviado por el “TCP Write”. Es necesario poner un botón de Stop para la estructura “While Loop” y un “Wait (ms)” para el ciclo se ejecute continuamente. Finamente se inserta un “TCP Close” para cerrar la conexión.
Cuando se finalizaron los programas de Arduino y de LabView se procedio a hacer pruebas para comprobar si había comunicación entre la PC y el Arduino.
En nuestro caso conectamos el Ethernet Shield a un modem al cual también estaba conectada la PC, después abrimos el Símbolo del Sistema e introducimos
el comando “ping + (IP del Arduino)”, y le damos Enter. Esperamos a que nos genere una repuesta, si esta respuesta termina en TTL=128 significa que la conexión es óptima. A continuación se muestra este procedimiento.
Sabiendo que hay comunicación entre la PC y el Arduino, pasamos a la ejecución del VI de LabView, solo recordando que hay que insertar la dirección IP y el Puerto que se le asignó al Arduino.
Ejecución del VI.
Al darle “run” al VI ya solo hay que oprimir el botón del escenario deseado y el programa le envía un carácter al Arduino que inmediatamente hace la comparación y le manda la señal a la tira de led´s RGB.
Persianas
Para las persianas se utilizó un motorreductor que es capaz de soportar hasta 15 kg de torque. Como es obvio el motor debe de girar hacia ambos lados y para hacer esta función fue implementado un “Puente H” el cual es muy utilizado para inversión de giro para motores de CD.
Circuito del puente H.
Los transistores utilizados para este circuito fueron los TIP120, fue necesario conectar una fuente externa para alimentar el circuito, y como se muestrea en el diagrama las entradas deben ser conectadas en las salidas digitales del Arduino.
Programación
La programación de las persianas en Arduino no fue muy difícil de realizar ya que solo se tenía que hacer que el Arduino leyera un carácter para abrirlas y otro para cerrarlas, de esta maneara solo se hizo una comparación.
if (Buffer[0] == '?'){
digitalWrite(2, HIGH);
delay(10000);
}
if (Buffer[0] == 'M'){
digitalWrite(4,HIGH);
delay(10000);
}
El carácter “?” es el que nos indica abrir persianas por el pin 2 y la “M” cerrarlas en el pin 4. Se les introdujo un delay para que el motor habrá y cierre de manera correcta.
Este programa solo se juntó con el anterior de la tira de led´s pero para el delay funcione debe de estar afuera de la condición “if (client){“ ya que como nuestro cliente no nos manda información de manera continua, sino solo cuando hay un evento, el delay no se detendrá.
Programa de Arduino Completo
#include <SPI.h>
#include <Ethernet.h>
const int rojo = 3;
const int verde = 5;
const int azul = 6;
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,77);
char Buffer[1024];
EthernetServer server(80);
void setup(){
Serial.begin(9600);
Ethernet.begin(mac, ip);
server.begin();
pinMode (7,OUTPUT);
pinMode(rojo,OUTPUT);
pinMode(verde,OUTPUT);
pinMode(azul,OUTPUT);
pinMode(2, OUTPUT);
pinMode(4, OUTPUT);
pinMode(8, INPUT);
pinMode(9, INPUT);
}
void loop() {
EthernetClient client = server.available();
int i=0;
if (client) {
while (client.available()) {
Buffer[i]=client.read();
Serial.print(Buffer[i]);
i++;
Buffer[i]='\0';}
//LED´S RGB
if (Buffer[0] == 'U'){
analogWrite(rojo,255);//rojo
analogWrite(verde,128);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
}
if (Buffer[0] == 'Q'){
analogWrite(rojo,0);//rojo
analogWrite(verde,46);//amarillo
analogWrite(azul,191);//celeste
digitalWrite(7, LOW);
}
if (Buffer[0] == 'S'){
analogWrite(rojo,255);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,255);//celeste
digitalWrite(7, HIGH);
}
if (Buffer[0] == 'W'){
analogWrite(rojo,0);//rojo
analogWrite(verde,153);//amarillo
analogWrite(azul,163);//celeste
digitalWrite(7, LOW);
}
if (Buffer[0] == 'E'){
analogWrite(rojo,255);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
delay(500);
analogWrite(rojo,0);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
delay(500);
}
if (Buffer[0] == 'O'){
analogWrite(rojo,0);//rojo
analogWrite(verde,0);//amarillo
analogWrite(azul,0);//celeste
digitalWrite(7, LOW);
}
//Riego
if (Buffer[0] == 'k'){
digitalWrite(10, HIGH);
}
if (Buffer[0] == 'K'){
digitalWrite(10, LOW);
}
}
//Perianas
if (Buffer[0] == '?'){
digitalWrite(2, HIGH);
delay(10000);
}
if (Buffer[0] == 'M'){
digitalWrite(4,HIGH);
delay(10000);
}
delay (100);
Buffer[0]='\0';
i=0;
}
Integración
Por Ultimo Se hizo la integración con el equipo de integración en el cual, nuestro Arduino con el programa ya cargado fue conectado en un Swich y para que su programa nos enviara un dato y así poder ejecutar alguno de nuestros actuadores.
Se hicieron varias pruebas previas para ver el funcionamiento, hubo algunos problemas pero solo eran con los comandos necesarios para ejecutar los actuadores.
Hojas TécnicasUNL2003
TIP120
MOC3011
MAC12
Top Related