Interfaz física de automatización del hogar

Acerca de este proyecto

Vea los dos videos a continuación para obtener una explicación rápida de este proyecto.

Una interfaz transmite información y permite al usuario controlar las cosas. La mayoría de las plataformas de automatización del hogar se basan en una "interfaz virtual". Sacas un teléfono inteligente y abres la aplicación para ver qué está pasando en tu casa y enciendes y apagas las luces. Eso funciona bien cuando no estás. Pero mirar una representación virtual y analizar la información en la pantalla requiere trabajo. Requiere concentración y no se siente intuitivo.

Quería hacer una "interfaz física", una pequeña casa modelo que imita físicamente las cosas que quiero saber con mi casa real. Entonces, cuando se abre la puerta del garaje, quiero que la puerta del garaje del modelo también se abra. Esta casa modelo podría sentarse en mi mesa de café, y puedo mirarla para ver si la puerta del garaje se ha dejado abierta antes de acostarme. O puedo tener esto en mi escritorio en el trabajo, conectado a mi casa a través de VPN. Cuando estoy en el trabajo, puedo mirarlo para ver si la puerta principal se ha dejado abierta. Esta interfaz física puede ser tan creativa o utilitaria como yo la haga.

Entonces, en los siguientes pasos,

1. Construya una casa modelo para mostrar elementos como la posición de la puerta, el uso de energía y si se ha dejado una luz encendida.
2. Construya un monitor de energía utilizando la biblioteca Arduino de Open Energy Monitor y envíe información sobre el uso de energía a la casa modelo y a OpenHAB
3. Proporcione un par de formas de enviar la posición de la puerta / ventana a la casa modelo. Muestre cómo los datos del sensor de contacto Wink Hub y Wink "Tripper" se pueden utilizar en un sistema domótico de bricolaje.
4. Utilice Wink y Arduino para realizar salidas, como abrir / cerrar la puerta del garaje o encender y apagar las luces.

La casa modelo tiene algunos servos y LED conectados a un controlador Arduino. Este controlador se suscribe a los mensajes MQTT que indican las posiciones de las puertas y el uso de energía, y activa los servos en consecuencia. Lo mismo ocurre con el LED que indica si una luz está encendida o apagada. Hay algunas opciones para llevar la información de este sensor al corredor de MQTT, así que lo detallaré en pasos posteriores. En medio de todo esto hay una Raspberry Pi que ejecuta un corredor MQTT (Mosquitto) y OpenHAB. Aunque OpenHAB no es necesario para ejecutar la casa modelo, es necesario para proporcionar la interfaz para la aplicación de teléfono inteligente y permitir el control y la activación remotos. El hecho de que quiera tener una interfaz física no significa que esté listo para descartar la virtual.

La casa modelo también tiene dos botones. Uno de los botones enciende / apaga una bombilla en zigbee. El otro botón abre y cierra la puerta del garaje (en la casa REAL).

Parte 1:Construcción de viviendas

1) Construir casa modelo

2) Opciones de control, cableado y código

Parte 2:Entradas (sensores)

3) Sensor:monitor de energía

4) Sensor:opción de nodo de sensor de bricolaje

5) Sensor:sensor de contacto Wink Hub y Tripper

Parte 3:Resultados

6) Luces

7) Abridor de puerta de garaje

Paso 1:Construcción de la casa modelo

No pretendo que este paso sea prescriptivo. Soy bastante aficionado cuando se trata de artes y manualidades, así que solo mostraré cómo construí mi casa modelo. Querrá construirlo para que se parezca a su propia vivienda y refleje las cosas que le importan. Aquí hay mucho espacio para la creatividad. Algunos de los componentes de esta imagen (como el transformador de corriente) se utilizarán en pasos posteriores.

Componentes :

• (1) Cuadro. Depende de usted qué tamaño y qué proporciones.
• (3) Servo Tower Pro SG90 http://www.dx.com/p/towerpro-sg90-9g-mini-servo-w ...
• (2) bisagras pequeñas http://www.homedepot.com/p/Stanley-National-Hardw ...
• (algo) Material adhesivo. Usé adhesivos de doble barra de ganchos 3M.
• Arduino Yun o Arduino Uno con escudo Ethernet.
• Buttonshttp://www.radioshack.com/mini-spst-1-5-amp-moment ...
• Cosas por la casa

Tejado

Corté una de las solapas laterales de la caja y la pegué a la otra solapa lateral (todavía unida) para formar un techo. Usé una caja pequeña para proporcionar una estructura para el ángulo recto y luego la apoyé mejor con una pieza de Lego. Probablemente pueda usar lo que tenga en la casa para hacer este ángulo recto.

Puertas / Ventanas

Corta los agujeros para las puertas que quieras mostrar. Coloque una o dos bisagras en la puerta con cinta adhesiva doble y fíjelas a la casa. Lo sé, nada lujoso, así que siéntete libre de improvisar con lo que tengas en casa. Usé adhesivos de espuma de doble cara de 3M, del tipo que viene con ganchos. También utilicé estas tiras adhesivas de espuma para montar los servomotores. Para la puerta del garaje, el brazo del servomotor abre la puerta del garaje y la gravedad cierra la puerta del garaje. Para la puerta de entrada, necesitaba unir una cuerda en la puerta con bisagras para que el brazo del servo pueda abrir la puerta. La pieza amarilla de Lego que ves está ahí para compensar el servo de la bisagra.

Contador de energía

Nada sofisticado. Simplemente corte una cosa que parezca una flecha y conéctela al brazo del servo. Recorte una forma que parezca un arbusto y márquela con una escala de kilovatios, y ajuste por fricción el servomotor en la caja con el arbusto en el medio.

Encima del servo de consumo de energía, coloqué un LED rojo.

También tengo dos botones para controlar las luces y la puerta del garaje. Estos son botones momentáneos. Los botones están roscados con una tuerca en el exterior para sujetarlo contra la pared de la caja de cartón. En el otro lado están los contactos de metal a los que se soldarán los cables.

Paso 2:Construcción de la casa:cables y código

Cableado

Aquí está el diagrama de cableado. Hice un desastre bastante grande con el cableado dentro de la caja. Si prefiere saber qué cables están en qué pines:

• LED de estado del pin:7
• LED indicador de iluminación:4
• Servo 1 (puerta de entrada):3
• Servo 2 (puerta de garaje):5
• Servo 3 (arbusto de uso de energía):6
• Botón 1 (luces encendidas / apagadas):8
• Botón 2 (puerta de garaje abierta / cerrada):9

Opciones del controlador

Puede usar aquello con lo que se sienta cómodo y lo que tenga a mano. Una opción menos costosa ($ 20) es usar un clon de Arduino Uno y un escudo ethernet. Empecé con eso, pero eso me ató al cable ethernet. Así que lo cambié a un Arduino Yun ($ 65). Mucho más caro, pero también me dio la libertad de usar wifi. El Yun fue realmente fácil de usar. Básicamente:

1. Conecte el Yun a su enrutador a través de Ethernet
2. Navegue a la página web de Yun
3. Configure contraseñas e IP estática en su enrutador
4. Descarga el boceto de Yun

A continuación se adjuntan los bocetos para Arduino Uno y Arduino Yun. Son bastante similares y, a excepción del puente ethernet que se usa en el Yun, puedes copiar el código Yun en el Uno. Después de hacer el cambio al Yun, agregué los dos botones de control. Como resultado, el boceto de Uno no tiene esos botones.

El video del primer paso muestra el Arduino Yun. Aquí hay un video que usa el escudo Uno y Ethernet. Cuando se hizo este video, aún no había instalado los dos botones, pero todo lo demás funciona igual.

Paso 3:Sensor:monitor de energía

Ahora que tenemos una interfaz física capaz de mostrar el uso de energía, necesitamos construir un nodo sensor para leer el consumo de energía de la casa y publicar ese consumo al corredor de MQTT. Hay un par de formas de hacer esto. Estoy usando un Arduino Yun. Es el método menos complicado, pero no el menos caro. Si lo desea, puede usar un Arduino Uno, un escudo ethernet y un enrutador inalámbrico para que actúe como un puente wifi. O puede usar un Pi con el paquete Open Energy Monitor. Solo cubriré el método Yun.

Estoy usando un transformador de corriente de $ 7 de eBay. Puede encontrar la versión 100A del Yhdc SCT-013-000 aquí. Conéctelo de acuerdo con el diagrama de cableado anterior y cargue el boceto de Arduino Yun en la parte inferior de este paso. Asegúrese de modificar el código con la dirección IP de su corredor de MQTT. Esta página de la biblioteca Open Energy Monitor es una buena referencia. Estos son los valores ideales de los componentes.

• Resistencia de carga =33 ohmios
• Resistencia del divisor de voltaje =10 k ohmios
• Condensador =10uF

La imagen de mi monitor de energía no coincide realmente con el diagrama del circuito porque no tenía esos componentes exactos a mano. Tuve que usar dos resistencias de 68 ohmios en paralelo porque no tenía la resistencia de carga de 33 ohmios. Y no tenía un condensador de 10uF para el circuito rectificador, así que usé dos condensadores de 22uF en su lugar. La capacitancia equivalente en serie es lo suficientemente cercana.

Conecte el transformador de corriente en una de las fases entrantes de su casa. Solo tenía un transformador de 100 A, por lo que solo estoy monitoreando una de las fases. Eventualmente, me gustaría tener más transformadores para monitorear la otra rama de la energía entrante y también los circuitos derivados. Usando un amperímetro real, mi configuración de bricolaje siempre lee 1 amperio por encima del amperímetro en diferentes lecturas de amperios (vea la quinta imagen de arriba). Bastante simple simplemente restar ese amplificador extra.

OpenHAB

Dado que tenemos los datos entrando, también podríamos mostrarlos en OpenHAB para que los datos se puedan graficar. Aquí está la configuración de OpenHAB relevante.

Definición de artículo

 

 Número itm_smarthome_energy_amps "Energía (amperios) [% .1f]" {mqtt ="<[mymosquitto:2853:estado:predeterminado]"} 
 

 Número itm_smarthome_energy_watts "Energía (vatios) [ % .1f] "{mqtt =" <[mymosquitto:2852:estado:predeterminado] "} 
 

Mapa del sitio

 

 Etiqueta de texto ="Energía" icon ="primer piso" 
 {
 

 Etiqueta de marco ="Uso de energía" {Elemento de texto =itm_smarthome_energy_amps 
 

 Elemento de texto =itm_smarthome_energy_watts 
 

 Gráfico item =itm_smarthome_energy_watts period =h refresh =5000} // Uso de energía del marco 
 

} // Etiqueta de texto ="Energía" 
 

Persistencia

Dado que estamos usando gráficos, necesitamos definir algún tipo de estrategia de persistencia para el uso de energía. RRD4J es más fácil de usar, así que esto es lo que tengo para "/openhab/configurations/persistence/rrd4j.persist".

 

 Estrategias {
 // para gráficos rrd, necesitamos una estrategia cron cada minuto:"0 * * * *?"} 
 

 Elementos {DemoSwitch, NoOfLights, Window_GF_Toilet, Heating * :estrategia =everyChange, everyMinute, restoreOnStartup // solo almacenemos los valores de temperatura en rrd Temperature *, Weather_Chart *:strategy =everyMinute, restoreOnStartup itm_smarthome_energy_watts:strategy =everyUpdate} 
 

Pantalla de monitor de energía

Paso 4:Sensor:Nodos de sensores inalámbricos de bricolaje

Hay algunas opciones para sensores inalámbricos de apertura / cierre.

En uno de mis proyectos anteriores, usé un transceptor inalámbrico de $ 5 para enviar datos de sensores a través de una puerta de enlace MQTT. Todavía estoy usando este proyecto para obtener el estado de la puerta del garaje en OpenHAB, y en el video de demostración, así es como la puerta del garaje de la casa modelo refleja el estado real de mi puerta de garaje. El código y el circuito detallados se pueden encontrar en este paso si desea utilizarlo. Es un poco feo, pero está en el garaje donde es probable que nadie se dé cuenta.

También hay un sensor de luz que estoy usando para indicar si se ha dejado una luz encendida. Esto también es de ese Instructable anterior detallado en este paso. Es parte del sensor Uber que usa una fotorresistencia para enviar información de brillo de forma inalámbrica a OpenHAB. En este caso, simplemente me suscribo al tema MQTT que indica el nivel de luz.

También hice un sensor de interruptor de láminas alimentado por batería que usa el mismo transceptor inalámbrico y puerta de enlace en ese Instructable anterior. Sin embargo, no es muy atractivo. Realmente no puedo usarlo en una puerta o ventana interior por razones estéticas. Entonces, para superar este problema, estoy usando sensores de interruptor de lengüeta para consumidores de Wink más atractivos. Lo que nos lleva al siguiente paso.

Paso 5:Sensor:Wink Hub

Me sucedió en esta publicación de blog de un usuario temprano de Wink Hub que encontró una manera de rootear el concentrador para obtener acceso a un exploit de PHP. Este exploit le permite ejecutar una utilidad "aprontest" para controlar las cosas que se han emparejado con Wink Hub. Con este método, he podido controlar las luces desde la interfaz OpenHAB.

El beneficio más interesante de rootear Wink Hub es que le brinda local control sobre las luces y el estado de los sensores sin tener que acceder al servidor Wink. Wink Hub y Wink API siempre deben conectarse a Internet para comunicarse con el servidor Wink para controlar la iluminación u obtener el estado del sensor. Ahora, con este exploit de PHP, las operaciones de iluminación y sensores pueden mantenerse en su LAN local. Eso es genial.

He incluido un script PHP al final de este paso. Si no puede abrir este archivo, pruebe este enlace. Este script se ejecuta en Raspberry Pi y consulta el Wink Hub para conocer el estado de dos interruptores de lengüeta Wink Tripper. Este estado se envía a OpenHAB a través de la API REST. OpenHAB luego publicará temas MQTT para estas posiciones de puertas. El controlador de la casa modelo abre o cierra las puertas suscribiéndose a estos temas de posición de la puerta.

Los tres archivos de configuración de OpenHAB (elementos, mapa del sitio y reglas) adjuntos en este paso son necesarios para que todo funcione. Definen los elementos de contacto con los que interactúa el script de sondeo a través de la interfaz REST. También hay un script de ejemplo para controlar la bombilla zigbee a través de OpenHAB.

Scripts y archivos de configuración.

Paso 6:Salida:luces

Debido al orden en que cubrí los archivos de configuración, los pasos anteriores proporcionaron prácticamente todo lo necesario para controlar una "bombilla de luz conectada" a través de la interfaz física y la interfaz OpenHAB. Las luces pueden ser cualquier luz que admita el concentrador Wink. Actualmente, lo he probado con Cree Connected Bulb y las luces GE Wink. Ambos funcionan como se esperaba. Lanzaré este video aquí que muestra mejor cómo el sensor de luz y los botones controlan la bombilla inteligente.

Paso 7:Salida:Abridor de puerta de garaje

Los archivos de configuración proporcionados en el Paso 5 incluyen la mayoría de los elementos de OpenHAB necesarios para controlar una puerta de garaje. Pero aún necesita algo para abrir y cerrar la puerta del garaje. Para eso, estoy modificando partes de un Instructable anterior. Hice un abre-puertas de garaje con estos componentes:

• Clon de Arduino ($ 10)
• Escudo de Ethernet ($ 7)
• Reed Relay ($ 2)
• Control remoto de repuesto para la puerta del garaje ($ 22)

El Arduino controla un relé de láminas abriendo y cerrando los contactos secos. El botón del abre-puertas de garaje de repuesto está conectado a través del contacto seco en el relé de lengüeta. Conecte el pin 5 y GND del Arduino a los dos pines de la bobina (dos pines exteriores) del relé de lengüeta y los pines del relé interior al botón del control remoto de la puerta del garaje.

El Arduino se suscribe a un tema MQTT y espera el comando abrir / cerrar. Cuando ve este tema, energiza el relé de lengüeta momentáneamente, cerrando el "botón" en el control remoto de la puerta del garaje de repuesto. El boceto de Arduino se adjunta a continuación. Además, agregue "garage_monitor_rules.txt" a su archivo de reglas. Esto es necesario además de las reglas adjuntas en el Paso 5. Si no usa el método de sensor ultrasónico que usé, esta es la parte que necesitaría cambiar para adaptarse a su modificación.

Si la puerta de su garaje es bastante tranquila o si desea algún tipo de anuncio de audio en otra parte de la casa para cuando se abra la puerta del garaje, la regla agregada anterior puede reproducir un archivo de audio. Puede escucharlo en el primer video de demostración aproximadamente en un minuto treinta pulgadas.

Paso 8:otros pensamientos

Las decisiones que se toman en este proyecto reflejan las herramientas con las que me siento cómodo, las piezas que tengo a mano y mis prioridades sobre cómo quiero que funcionen las cosas. Probablemente tenga un conjunto diferente de herramientas y tenga diferentes componentes de hardware disponibles. Probablemente también tenga diferentes ideas sobre cómo debería funcionar la automatización del hogar.

Hay mucha flexibilidad al usar MQTT y OpenHAB, y no es necesario que haga las cosas exactamente como las hice yo. El controlador utilizado para controlar la casa modelo puede ser un sabor de Arduino, una Raspberry Pi o incluso un Sparkcore. Los sensores de bricolaje pueden ser un Arduino o un ESP8266 independiente. La única restricción es que los datos del sensor deben publicarse en el corredor de MQTT de alguna manera. Si tiene un dispositivo USB Z-wave en la instalación de OpenHAB, puede usar OpenHAB como un puente Z-wave a MQTT y utilizar sensores de Z-wave para la detección de puertas.

Incluso los sensores de apertura / cierre de Wink podrían realizarse de manera diferente. Si no rooteas el Wink Hub, puedes usar la API de Wink para tomar el estado del sensor y publicarlos en OpenHAB, o publicarlos directamente a través de MQTT. Esto requiere el uso del servidor Wink, pero elimina la restricción de un concentrador rooteado.

Entonces, hay muchas formas de hacer las cosas de manera diferente. Tiendo a usar hardware que es el mínimo común denominador, por lo que Arduino y cajas de cartón.

Código

• smarthome_yun.ino
• smarthome_ethernet.ino
• energy_monitor_yun.ino

smarthome_yun.ino Texto sin formato

 // Eric Tsai // 2015-04-13 // Código Arduino Yun para controlar la interfaz física del hogar inteligente // Modificar los nombres de los temas MQTT para que coincidan con su uso // Modificar la dirección IP del corredor MQTT // El nuevo yun incluye # incluir  #include  #include  // ethernet antiguo se incluye cuando se usa ethernet shield / * # include  #include  #include  * / # include  // Configuración del escudo de Ethernet / * IPAddress ip (192, 168, 2, 36); byte mac [] ={0x90, 0xA2, 0xDA, 0x0D, 0x43, 0x13}; byte servidor [ ] ={192, 168, 1, 101}; EthernetClient ethClient; PubSubClient client (servidor, 1883, callback, ethClient); * / unsigned long keepalivetime =0; unsigned long MQTT_reconnect =0; // use yunclient para hacer un puente a la red YunClient yun; // equivalente de ethernet clientPubSubClient client ("192.168.1.101", 1883, callback, yun); bool conn_ok; // use LED para indicar el estado de la conexión MQTT.int ledPin =4; // indica luces onint statusPin =7; // indica el estado de conexión MQTT // servo controlint servo1Pin =3; // puerta de entrada servo2Pin =5; // puerta de garaje servo3Pin =6; // medidor de consumo de energíaServo servo1; // doorServo servo2; // puerta de garajeServo servo3; // energyint button1 =8; // botón sobre la puerta de entrada button2 =9; // botón sobre la puerta del garaje // funcionamiento del servo:posiciones de destino para servosint servo1_target =5; // puerta, closedint servo2_target =5; // garaje, closedint servo3_target =180; // energía, 180 es "0" vatios, motor montado al revésint servo1_pos_cur =5; int servo2_pos_cur =5; int servo3_pos_cur =180; // 180 es "0" vatios, motor montado al revésint servo1Opened =5; int servo1Closed =130; int servo2Opened =5; int servo2Closed =150; unsigned long servo1_time =0; unsigned long servo2_time =0; unsigned long servo3_time =0; / / debounce en los botones, para que no envíe spam publishunsigned long button1_db =0; unsigned long button2_db =0; int button =0; int callback_flag =0; char buff_message [12]; // --------- -------------------------------------------------- ---- // MQTT call back // reacciona a los mensajes MQTT aquí // -------------------------------- ------------------------------- devolución de llamada void (char * tema, byte * carga útil, longitud int sin firmar) {// convertir tema a int. int mytopic =atoi (tema); //Serial.print(mytopic); // convierte la carga útil en int payload [longitud] ='\ 0'; // agregue un retorno de línea para que atof pueda analizar correctamente float mymsg =atof ((const char *) payload); // led if (mytopic ==2822) {if (mymsg ==1) {digitalWrite (ledPin, HIGH); } if (mymsg ==0) {digitalWrite (ledPin, LOW); }} // servo 1, puerta de entrada if (mytopic ==2832) {if (mymsg ==1) // open {//Serial.println("servo1 open "); servo1_target =servo1Opened; } if (mymsg ==0) // cerrado {//Serial.println("servo1 cerrado "); servo1_target =servo1Closed; } //Serial.println(servo1_target); } / * // segunda señal de puerta de garaje "cerrado" =apagado =enviar 1 "abierto" =encendido =enviar 0 * / // servo 2, puerta de garaje if (mytopic ==2842) {if (mymsg ==1) / / open {servo2_target =servo2Opened; } if (mymsg ==0) // cerrado {servo2_target =servo2Closed; } // callback_flag =1; // servo3_target =mymsg; } // servo 3, medidor de energía if (mytopic ==2852) {// mensaje =vatios // vatios ligados al medidor max &min if (mymsg> 6000) {mymsg =6000; } si (mymsg <0) {mymsg =0; } //bias meter from 180 degrees to 0 degrees //180 deg to 0 deg =0 watt to 6000 watts, for example //set max watts to what makes sense for you. servo3_target =180-((1-((6000-mymsg)/6000))*180)-25; callback_flag=1; }}//end callbackvoid setup() { pinMode(ledPin, OUTPUT); //LED indicating light on pinMode(statusPin, OUTPUT); pinMode(button1, INPUT_PULLUP); //use pull-up resistor, invert logic pinMode(button2, INPUT_PULLUP); //use pull-up resistor, invert logic digitalWrite(ledPin, HIGH); //yun bridge Bridge.begin(); //connect to MQTT broker client.connect("yun smarthome"); client.publish("watch", "Smart Home Connected!"); keepalivetime=millis(); //Wire.onReceive (receiveEvent); MQTT_reconnect =millis(); //client.subscribe("#"); //test subscribe client.subscribe("2822"); //LED client.subscribe("2832"); //servo 1 topic client.subscribe("2842"); //servo 2 topic client.subscribe("2852"); //servo 3 topic digitalWrite(ledPin, LOW); //servo servo1.attach(servo1Pin); servo1.write(90); servo2.attach(servo2Pin); servo2.write(90); servo3.attach(servo3Pin); servo3.write(5);} // end of setupvoid loop() { client.loop(); //MQTT processing needs this to run //For servo positioning, don't want to move too fast. //Must crawl from current position to target position //but also avoid using "delay" cmd, that just freezes up microcontroller //servo 1 if ((millis() - servo1_time)> 20) { if (servo1_pos_cur> servo1_target) { servo1_pos_cur =servo1_pos_cur - 1; } if (servo1_pos_cur  20) { if (servo2_pos_cur> servo2_target) { servo2_pos_cur =servo2_pos_cur - 1; } if (servo2_pos_cur  20) { if (servo3_pos_cur> servo3_target) { servo3_pos_cur =servo3_pos_cur - 1; } if (servo3_pos_cur 3000) || (button1_db> millis())) { button1_db=millis(); client.publish("2862", "button1 yaya"); } } //button 2 button=digitalRead(button2); if (button==0) //inverted logic { if ( ((millis() - button2_db)>3000) || (button2_db> millis())) { button2_db=millis(); client.publish("2872", "button2 yaya"); } } //check network connection to MQTT broker every 60 seconds. //reconnect if no longer connected if ((millis() - MQTT_reconnect)> 60000) { conn_ok =client.connected(); if (conn_ok==1) { digitalWrite(statusPin, HIGH); //Serial.println("MQTT connected OK"); } else { digitalWrite(statusPin, LOW); //Serial.println("MQTT NOT connected OK"); } //no connection, reconnect if (conn_ok ==0) { client.disconnect(); retraso (5000); while (client.connect("smarthouse") !=1) { digitalWrite(statusPin, LOW); //Serial.println("Error connecting to MQTT"); retraso (4000); } digitalWrite(statusPin, HIGH); } //Serial.println("reconnected to MQTT"); MQTT_reconnect =millis(); client.publish("watch","smart home heartbeat!"); }//end Mosquitto connection check} // end of loop

smarthome_ethernet.inoPlain text

// Eric Tsai// 2015-04-1// Arduino Uno w/ Ethernet, code for controlling physical smart home interface// Modify MQTT topic names to match your use// Modify MQTT broker IP address#include #include #include #include //Ethernetbyte mac[] ={ 0x90, 0xA2, 0xDA, 0x0D, 0x43, 0x13 };byte server[] ={ 192, 168, 1, 101 };EthernetClient ethClient;PubSubClient client(server, 1883, callback, ethClient);unsigned long keepalivetime=0;unsigned long MQTT_reconnect=0;bool conn_ok;//use LED for indicating MQTT connection status.int ledPin =4; //indicate lights onint statusPin =7; //indicate MQTT conn status//servo controlint servo1Pin =3; //front doorint servo2Pin =5; //garage doorint servo3Pin =6; //energy usage meterServo servo1; //doorServo servo2; //garage doorServo servo3; //energy//servo operation:target positions for servosint servo1_target =5; //door, closedint servo2_target =5; //garage, closedint servo3_target =180; //energy, 180 is "0" watts, motor mounted backwardsint servo1_pos_cur =5;int servo2_pos_cur =5;int servo3_pos_cur =180; // 180 is "0" watts, motor mounted backwardsint servo1Opened =5;int servo1Closed =120;int servo2Opened =5;int servo2Closed =150;unsigned long servo1_time =0;unsigned long servo2_time =0;unsigned long servo3_time =0;//---------------------------------------------------------------// MQTT call back// react to MQTT messages here//---------------------------------------------------------------void callback(char* topic, byte* payload, unsigned int length) { Serial.println("received MQTT"); //convert topic to int. int mytopic =atoi (topic); //Serial.print(mytopic); //convert payload to int payload[length] ='\0'; //add a line return so atof can parse correctly float mymsg =atof( (const char *) payload); //print MQTT message Serial.println(""); Serial.print("("); Serial.print(mytopic); Serial.print(", "); Serial.print(mymsg); Serial.println(")"); //led if (mytopic ==2822) { if (mymsg ==1) { digitalWrite(ledPin, HIGH); } if (mymsg ==0) { digitalWrite(ledPin, LOW); } } //servo 1, front door if (mytopic ==2832) { if (mymsg ==1) //opened { Serial.println("servo1 opened"); servo1_target =servo1Opened; } if (mymsg ==0) //closed { Serial.println("servo1 closed"); servo1_target =servo1Closed; } Serial.println(servo1_target); } /* //second garage door signal "closed" =off =send 1 "open" =on =send 0 */ //servo 2, garage door if (mytopic ==2842) { if (mymsg ==1) //opened { servo2_target =servo2Opened; } if (mymsg ==0) //closed { servo2_target =servo2Closed; } } //servo 3, energy meter if (mytopic ==2852) { //message =watts //error check if (mymsg> 6000) { mymsg =6000; } if (mymsg <0) { mymsg =0; } //bias meter from 180 degrees to 0 degrees //180 deg to 0 deg =0 watt to 6000 watts, for example //set max watts to what makes sense for you. servo3_target =180-((1-((6000-mymsg)/6000))*180); //servo3_target =mymsg; }}//end callbackvoid setup() { //ethernet //Ethernet.begin(mac, ip); //Wire.begin (MY_ADDRESS); Serial.begin (9600); Serial.println("starting"); pinMode (ledPin, SALIDA); //LED indicating light on pinMode(statusPin, OUTPUT); digitalWrite(ledPin, HIGH); //wait for IP address while (Ethernet.begin(mac) !=1) { Serial.println("Error getting IP address via DHCP, trying again..."); retraso (5000); } Serial.println("ethernet OK"); keepalivetime=millis(); while (client.connect("smarthouse") !=1) { Serial.println("Error connecting to MQTT"); //delay(3000); retraso (4000); } MQTT_reconnect =millis(); Serial.println("setup complete"); client.publish("smarthouse","hello world"); //test publish //client.subscribe("#"); //test subscribe client.subscribe("2822"); //LED client.subscribe("2832"); //servo 1 topic client.subscribe("2842"); //servo 2 topic client.subscribe("2852"); //servo 2 topic digitalWrite(ledPin, LOW); //servo servo1.attach(servo1Pin); servo1.write(90); servo2.attach(servo2Pin); servo2.write(90); servo3.attach(servo3Pin); servo3.write(5);} // end of setupvoid loop() { client.loop(); //MQTT processing needs this to run //For servo positioning, don't want to move too fast. //Must crawl from current position to target position //but also avoid using "delay" cmd, that just freezes up microcontroller //servo 1 if ((millis() - servo1_time)> 20) { if (servo1_pos_cur> servo1_target) { servo1_pos_cur =servo1_pos_cur - 1; } if (servo1_pos_cur  20) { if (servo2_pos_cur> servo2_target) { servo2_pos_cur =servo2_pos_cur - 1; } if (servo2_pos_cur  20) { if (servo3_pos_cur> servo3_target) { servo3_pos_cur =servo3_pos_cur - 1; } if (servo3_pos_cur  60000) { conn_ok =client.connected(); if (conn_ok==1) { digitalWrite(statusPin, HIGH); Serial.println("MQTT connected OK"); } else { digitalWrite(statusPin, LOW); Serial.println("MQTT NOT connected OK"); } //no connection, reconnect if (conn_ok ==0) { client.disconnect(); retraso (5000); while (client.connect("smarthouse") !=1) { digitalWrite(statusPin, LOW); Serial.println("Error connecting to MQTT"); retraso (4000); } digitalWrite(statusPin, HIGH); } //Serial.println("reconnected to MQTT"); MQTT_reconnect =millis(); client.publish("smarthouse","heartbeat every minute!"); }//end Mosquitto connection check} // end of loop

energy_monitor_yun.inoPlain text

/*Eric Tsai2015-04-22Arduino Yun code for publishing energy use to MQTT brokerModify the "PubSubClient client" for your broker IP address*/#include #include #include #include "EmonLib.h" // OpenEnergy Monitor project libraryint LED =3;EnergyMonitor emon1; // open energy monitorunsigned long MQTT_reconnect=0;unsigned long read_energy=0;double Irms;bool conn_ok;YunClient yun; //equivalent of ethernet client//really shouldn't need call back, but just in case it's needed.void callback(char* topic, byte* payload, unsigned int length) { digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level) delay(500); // wait for a second digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW}//use yunclient to bridge to networkPubSubClient client("192.168.1.101", 1883, callback, yun);//**********************************************************************void setup(){ // initialize digital pin 13 as an output. pinMode(LED, OUTPUT); digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW Bridge.begin(); client.connect("yun_energy"); client.publish("watch", "Energy Monitor Connected!"); client.subscribe("yun_energy"); digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level) delay(3000); // wait for a second digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW emon1.current(5, 60); // Current:input pin, calibration.}//**********************************************************************void loop(){ char buff_message[12]; //message buffer for MQTT publish float value; client.loop(); //run this every loop to maintain MQTT connection Irms =emon1.calcIrms(1480); // Calculate Irms only, 1480 means read Irms. //publish current every 10 seconds. if (millis() - read_energy> 10000) { //amps value =Irms; dtostrf (value, 4, 5, buff_message); client.publish("2853", buff_message); read_energy =millis(); //watts value =Irms*115; dtostrf (value, 4, 5, buff_message); client.publish("2852", buff_message); } //maintain MQTT connection if ((millis() - MQTT_reconnect)> 60000) { conn_ok =client.connected(); if (conn_ok==1) { digitalWrite(LED, HIGH); } else { digitalWrite(LED, LOW); } //no connection, reconnect if (conn_ok ==0) { client.disconnect(); retraso (5000); while (client.connect("yun_energy") !=1) { delay(4000); } digitalWrite(LED, HIGH); client.publish("watch", "Energy Monitor reconnected"); } MQTT_reconnect =millis(); }//end Mosquitto connection check }

Esquemas

Robot quitanieves Aléjate del retraso