Interface domotique physique

À propos de ce projet

Voir les deux vidéos ci-dessous pour une explication rapide de ce projet.

Une interface véhicule des informations et permet à l'utilisateur de contrôler les choses. La plupart des plateformes domotiques s'appuient sur une « interface virtuelle ». Vous sortez un téléphone intelligent et ouvrez l'application pour voir ce qui se passe dans votre maison et allumer et éteindre les lumières. Cela fonctionne bien lorsque vous êtes absent. Mais regarder une représentation virtuelle et analyser les informations à l'écran demande du travail. Cela nécessite de la concentration et ne semble pas intuitif.

Je voulais faire une "interface physique" - une petite maison modèle qui imite physiquement les choses que je veux savoir avec ma vraie maison. Ainsi, lorsque la porte de garage est ouverte, je veux que la porte de garage du modèle s'ouvre également. Cette maison modèle pourrait s'asseoir sur ma table basse, et je peux y jeter un coup d'œil pour voir si la porte du garage a été laissée ouverte avant d'aller me coucher. Ou je peux l'avoir sur mon bureau au travail, connecté à ma maison via VPN. Quand je suis au travail, je peux y jeter un coup d'œil pour voir si la porte d'entrée est restée ouverte. Cette interface physique peut être aussi créative ou aussi utilitaire que je la fais.

Donc, dans les étapes suivantes, je vais

1. Construisez une maison modèle pour afficher des éléments tels que la position de la porte, la consommation d'énergie et si une lumière a été laissée allumée.
2. Créez un moniteur d'énergie à l'aide de la bibliothèque Open Energy Monitor Arduino et fournissez des informations sur la consommation d'énergie à la maison modèle et à OpenHAB
3. Fournissez deux manières d'envoyer la position de la porte/fenêtre à la maison modèle. Montrez comment les données du capteur de contact Wink Hub et Wink "Tripper" peuvent être utilisées dans un système domotique de bricolage.
4. Utilisez Wink et Arduino pour effectuer des sorties, comme ouvrir/fermer la porte du garage ou allumer et éteindre les lumières.

La maison modèle a des servos et des LED câblés à un contrôleur Arduino. Ce contrôleur s'abonne aux messages MQTT qui indiquent les positions des portes et la consommation d'énergie, et actionne les servos en conséquence. Même idée avec la LED qui indique si une lumière est allumée ou éteinte. Il existe quelques options pour transmettre ces informations de capteur au courtier MQTT, je les détaillerai donc dans les étapes ultérieures. Au milieu de tout cela se trouve un Raspberry Pi exécutant un courtier MQTT (Mosquitto) et OpenHAB. Bien qu'OpenHAB ne soit pas nécessaire pour faire fonctionner la maison modèle, il est nécessaire pour fournir l'interface de l'application pour smartphone et permettre la surveillance et l'actionnement à distance. Ce n'est pas parce que je veux avoir une interface physique que je suis prêt à jeter l'interface virtuelle.

La maison modèle dispose également de deux boutons. L'un des boutons allume/éteint une ampoule zigbee. L'autre bouton ouvre et ferme la porte du garage (sur la VRAIE maison).

Partie 1 :Construction d'une maison

1) Construire une maison modèle

2) Options de contrôle, câblage et code

Partie 2 :Entrées (Capteurs)

3) Capteur :Moniteur d'énergie

4) Capteur :option de nœud de capteur DIY

5) Capteur :capteur de contact Wink Hub &Tripper

Partie 3 :Résultats

6) Lumières

7) Ouvre-porte de garage

Étape 1 :Construction d'une maison modèle

Je n'ai pas l'intention que cette étape soit normative. Je suis assez mature en matière d'art et d'artisanat, alors je vais juste montrer comment j'ai construit ma maison modèle. Vous voudrez le construire pour ressembler à votre propre logement et refléter les choses qui vous tiennent à cœur. Beaucoup de place pour la créativité ici. Certains des composants de cette image (comme le transformateur de courant) seront utilisés dans les étapes ultérieures.

Composants :

• (1) Boîte. C'est à vous de décider quelle taille et quelles proportions.
• (3) Servo Tower Pro SG90 http://www.dx.com/p/towerpro-sg90-9g-mini-servo-w...
• (2) petites charnières http://www.homedepot.com/p/Stanley-National-Hardw...
• (certains) Matériau adhésif. J'ai utilisé des adhésifs double bâton de crochets 3M.
• Arduino Yun ou Arduino Uno avec blindage Ethernet.
• Boutonshttp://www.radioshack.com/mini-spst-1-5-amp-moment...
• Des trucs qui traînent dans la maison

Toit

J'ai découpé l'un des rabats latéraux de la boîte et je l'ai attaché à l'autre rabat latéral (toujours attaché) pour former un toit. J'ai utilisé une petite boîte pour fournir une structure pour l'angle droit, et plus tard, je l'ai mieux soutenue avec une pièce Lego. Vous pouvez probablement simplement utiliser tout ce que vous avez dans la maison pour faire cet angle droit.

Portes / Fenêtres

Découpez les trous pour les portes que vous souhaitez montrer. Fixez une charnière ou deux sur la porte avec du ruban adhésif double et fixez-la à la maison. Je sais, rien d'extraordinaire, alors n'hésitez pas à improviser avec ce que vous avez dans la maison. J'ai utilisé des adhésifs en mousse double face 3M, le genre qui vient avec des crochets. J'ai également utilisé ces bandes adhésives en mousse pour monter les servomoteurs. Pour la porte de garage, le bras du servomoteur ouvre la porte de garage et la gravité ferme la porte de garage. Pour la porte d'entrée, j'avais besoin d'attacher une ficelle sur la porte à charnière pour que le bras servo puisse ouvrir la porte. La pièce Lego jaune que vous voyez est là pour décaler le servo de la charnière.

Compteur d'énergie

Rien d'extraordinaire. Découpez simplement un objet en forme de flèche et attachez-le au bras du servo. Découpez une forme ressemblant vaguement à un arbuste et marquez-la avec une échelle en kilowatts, et ajustez par friction le servomoteur sur la boîte avec l'arbuste entre les deux.

Au-dessus du servo de consommation d'énergie, j'ai scotché une LED rouge.

J'ai aussi deux boutons pour contrôler les lumières et la porte de garage. Ce sont des boutons momentanés. Les boutons sont filetés avec un écrou à l'extérieur pour le maintenir contre la paroi de la boîte en carton. De l'autre côté se trouvent les contacts métalliques pour les fils à souder.

Étape 2 :Construction de la maison – Câbles et code

Câblage

Voici le schéma de câblage. J'ai fait un assez gros gâchis du câblage à l'intérieur de la boîte. Si vous préférez simplement savoir quels fils sont sur quelles broches :

• LED de la broche d'état : 7
• voyant d'éclairage LED : 4
• Servo 1 (porte d'entrée) :3
• Servo 2 (porte de garage) :5
• Servo 3 (arbuste de consommation d'énergie) :6
• Bouton 1 (Voyants allumés/éteints) :8
• Bouton 2 (ouverture/fermeture de la porte du garage) : 9

Options du contrôleur

Vous pouvez utiliser ce avec quoi vous êtes à l'aise et ce que vous avez sous la main. Une option moins chère (20 $) consiste à utiliser un clone Arduino Uno et un bouclier Ethernet. J'ai commencé avec ça, mais cela m'a attaché au câble Ethernet. Je l'ai donc basculé sur un Arduino Yun (65 $). Beaucoup plus cher, mais m'a aussi donné la liberté d'utiliser le wifi. Le Yun était vraiment facile à utiliser. En gros, vous :

1. Connectez le Yun à votre routeur via Ethernet
2. Accéder à la page Web de Yun
3. Configurer les mots de passe et l'IP statique sur votre routeur
4. Télécharger le croquis Yun

Vous trouverez ci-dessous les croquis pour un Arduino Uno et un Arduino Yun. Ils sont assez similaires, et à l'exception du pont Ethernet utilisé dans le Yun, vous pouvez à peu près copier le code Yun sur le Uno. Après avoir basculé sur le Yun, j'ai ajouté les deux boutons de commande. Par conséquent, l'esquisse Uno n'a pas ces boutons.

La vidéo de la première étape montre l'Arduino Yun. Voici une vidéo utilisant le bouclier Uno et Ethernet. Lorsque cette vidéo a été réalisée, je n'avais pas encore installé les deux boutons, mais tout le reste fonctionne de la même manière.

Étape 3 : Capteur : Moniteur d'énergie

Maintenant que nous avons une interface physique capable d'afficher la consommation d'énergie, nous devons créer un nœud de capteur pour lire la consommation d'énergie de la maison et publier cette consommation sur le courtier MQTT. Il y a plusieurs façons de le faire. J'utilise un Arduino Yun. C'est la méthode la moins compliquée, mais pas la moins chère. Si vous le souhaitez, vous pouvez utiliser un Arduino Uno, un blindage Ethernet et un routeur sans fil pour servir de pont wifi. Ou vous pouvez utiliser un Pi avec le package Open Energy Monitor. Je vais juste couvrir la méthode Yun.

J'utilise un transformateur de courant à 7 $ d'ebay. Vous pouvez trouver la version 100A du Yhdc SCT-013-000 ici. Câblez-le selon le schéma de câblage ci-dessus et téléchargez le croquis Arduino Yun au bas de cette étape. Assurez-vous de modifier le code avec l'adresse IP de votre courtier MQTT. Cette page de la bibliothèque Open Energy Monitor est une bonne référence. Voici les valeurs idéales des composants.

• Résistance de charge =33 ohms
• Résistance diviseur de tension =10k ohm
• Condensateur =10uF

L'image de mon moniteur d'énergie ne correspond pas vraiment au schéma de circuit car je n'avais pas ces composants exacts sous la main. J'ai dû utiliser deux résistances de 68 ohms en parallèle car je n'avais pas la résistance de charge de 33 ohms. Et je n'avais pas de condensateur 10uF pour le circuit redresseur, j'ai donc utilisé deux condensateurs 22uF à la place. La capacité équivalente en série est assez proche.

Fixez le transformateur de courant sur l'une des phases entrantes de votre maison. Je n'avais qu'un seul transformateur 100A, donc je ne surveille qu'une des phases. Finalement, j'aimerais avoir plus de transformateurs pour surveiller l'autre branche de l'alimentation entrante ainsi que les circuits de dérivation. En utilisant un ampèremètre réel, ma configuration de bricolage lit toujours 1 ampère au-dessus de l'ampèremètre sur différentes lectures d'ampères (voir 5ème image ci-dessus). Question assez simple pour soustraire simplement cet ampli supplémentaire.

OpenHAB

Puisque nous avons les données qui arrivent, nous pourrions aussi bien les afficher sur OpenHAB afin que les données puissent être représentées graphiquement. Voici la configuration OpenHAB appropriée.

Définition de l'élément

Numéro itm_smarthome_energy_amps "Énergie (ampères) [%.1f]" {mqtt="<[mymosquitto:2853:state:default]"}

Numéro itm_smarthome_energy_watts "Énergie (Watts) [ %.1f]" {mqtt="<[mymosquitto:2852:state:default]"}

Plan du site

Texte label="Energy" icon="firstfloor"
{

 Frame label="Energy Usage" { Text item=itm_smarthome_energy_amps

 Text item=itm_smarthome_energy_watts

 Chart item=itm_smarthome_energy_watts period=h refresh=5000 } //Consommation d'énergie du cadre

}//Text label="Energy"

Persistance

Puisque nous utilisons des graphiques, nous devons définir une sorte de stratégie de persistance pour la consommation d'énergie. RRD4J est le plus simple à utiliser, alors voici ce que j'ai pour "/openhab/configurations/persistence/rrd4j.persist".

Stratégies {
 // pour les graphiques rrd, nous avons besoin d'une stratégie cron everyMinute :"0 * * * * ?"}

Items { DemoSwitch,NoOfLights,Window_GF_Toilet,Heating* :strategy =everyChange, everyMinute, restoreOnStartup // stockons uniquement les valeurs de température dans rrd Temperature*,Weather_Chart* :strategy =everyMinute, restoreOnStartup itm_smarthome_energy_watts :strategy =everyUpdate}

Écran du moniteur d'énergie

Étape 4 :Capteur :Noeuds de capteur sans fil DIY

Il existe quelques options pour les capteurs d'ouverture/fermeture sans fil.

Dans l'un de mes projets précédents, j'ai utilisé un émetteur-récepteur sans fil à 5 ​​$ pour envoyer des données de capteur sur une passerelle MQTT. J'utilise toujours ce projet pour obtenir le statut de la porte de garage sur OpenHAB, et dans la vidéo de démonstration, c'est en fait comment la porte de garage de la maison modèle reflète mon statut réel de porte de garage. Le code détaillé et le circuit peuvent être trouvés dans cette étape si vous souhaitez l'utiliser. C'est un peu moche, mais c'est dans le garage où personne ne le remarquera probablement.

Il y a aussi un capteur de lumière que j'utilise pour indiquer si une lumière a été laissée allumée. C'est également à partir de ce précédent Instructable détaillé dans cette étape. Il fait partie du capteur Uber qui utilise une photorésistance pour renvoyer sans fil les informations de luminosité à OpenHAB. Dans ce cas, je m'abonne simplement au sujet MQTT qui indique le niveau de luminosité.

J'ai également fabriqué un capteur de commutateur à lames alimenté par batterie qui utilise le même émetteur-récepteur sans fil et la même passerelle dans ce précédent Instructable. Cependant, ce n'est pas très beau. Je ne peux pas vraiment l'utiliser sur une porte ou une fenêtre intérieure pour des raisons esthétiques. Donc, pour surmonter ce problème, j'utilise des capteurs de commutateur à lames de qualité grand public de Wink. Ce qui nous amène à l'étape suivante.

Étape 5 : Capteur :Wink Hub

Je suis tombé sur cet article de blog d'un des premiers utilisateurs de Wink Hub qui a trouvé un moyen de rooter le hub pour accéder à un exploit PHP. Cet exploit vous permet d'exécuter un utilitaire "aprontest" pour contrôler les éléments qui ont été associés au Wink Hub. En utilisant cette méthode, j'ai pu contrôler les lumières depuis l'interface OpenHAB.

L'avantage le plus intéressant de l'enracinement du Wink Hub est qu'il vous donne local contrôle des lumières et de l'état des capteurs sans avoir à accéder au serveur Wink. Le Wink Hub et l'API Wink doivent toujours aller sur Internet pour contacter le serveur Wink afin de contrôler l'éclairage ou d'obtenir l'état du capteur. Désormais, avec cet exploit PHP, les opérations d'éclairage et de capteur peuvent être conservées sur votre réseau local local. C'est super.

J'ai inclus un script PHP au bas de cette étape. Si vous ne pouvez pas ouvrir ce fichier, essayez ce lien. Ce script s'exécute sur le Raspberry Pi et interroge le Wink Hub pour connaître l'état de deux commutateurs à lames Wink Tripper. Ce statut est envoyé à OpenHAB via l'API REST. OpenHAB publiera ensuite les sujets MQTT pour ces positions de porte. Le contrôleur de la maison modèle ouvre ou ferme ensuite les portes en s'abonnant à ces rubriques sur la position des portes.

Les trois fichiers de configuration OpenHAB (éléments, plan du site et règles) joints à cette étape sont nécessaires pour que tout fonctionne. Ils définissent les éléments de contact avec lesquels le script d'interrogation interagit via l'interface REST. Il existe également un exemple de script pour contrôler l'ampoule zigbee via OpenHAB.

Scripts et fichiers de configuration.

Étape 6 :Sortie :Lumières

En raison de l'ordre dans lequel j'ai couvert les fichiers de configuration, les étapes précédentes ont fourni à peu près tout le nécessaire pour contrôler une "ampoule connectée" via l'interface physique et l'interface OpenHAB. Les lumières peuvent être n'importe quelle lumière prise en charge par le hub Wink. Actuellement, j'ai testé cela avec l'ampoule connectée Cree et les lumières GE Wink. Les deux fonctionnent comme prévu. Je vais juste lancer cette vidéo ici qui montre mieux comment le capteur de lumière et les boutons contrôlent l'ampoule intelligente.

Étape 7 :Sortie :Ouvre-porte de garage

Les fichiers de configuration fournis à l'étape 5 incluent la plupart des éléments OpenHAB nécessaires pour contrôler une porte de garage. Mais vous avez toujours besoin de quelque chose pour ouvrir et fermer la porte de garage. Pour cela, je modifie des parties d'un précédent Instructable. J'ai fabriqué un ouvre-porte de garage avec ces composants :

• Clone Arduino (10 $)
• Blindage Ethernet (7 $)
• Relais Reed (2 $)
• Télécommande de porte de garage de rechange (22 $)

L'Arduino contrôle un relais Reed en ouvrant et en fermant les contacts secs. Le bouton de l'ouvre-porte de garage de rechange est câblé sur le contact sec du relais à lames. Connectez les broches 5 et GND de l'Arduino aux deux broches de la bobine (deux broches externes) du relais Reed et les broches internes du relais au bouton de la télécommande de la porte de garage.

L'Arduino s'abonne à un sujet MQTT et attend la commande d'ouverture/fermeture. Lorsqu'il voit ce sujet, il alimente momentanément le relais Reed, fermant le "bouton" de la télécommande de porte de garage de rechange. Le croquis Arduino est joint ci-dessous. De plus, ajoutez le "garage_monitor_rules.txt" à votre fichier de règles. Ceci est nécessaire en plus des règles jointes à l'étape 5. Si vous n'utilisez pas la méthode du capteur à ultrasons que j'ai utilisée, c'est la partie que vous devrez modifier en fonction de votre modification.

Si votre porte de garage est assez calme ou si vous souhaitez une sorte d'annonce audio dans une autre partie de la maison lorsque la porte de garage s'ouvre, la règle ajoutée ci-dessus peut lire un fichier audio. Vous pouvez l'entendre dans la première vidéo de démonstration environ une minute trente.

Étape 8 :Autres pensées

Les décisions prises dans ce projet reflètent les outils avec lesquels je suis à l'aise, les pièces que j'ai sous la main et mes priorités quant à la façon dont je veux que les choses fonctionnent. Vous disposez probablement d'un ensemble d'outils différent et vous disposez de différents composants matériels facilement disponibles. Vous avez probablement aussi des idées différentes sur la façon dont la domotique devrait fonctionner.

Il y a beaucoup de flexibilité lors de l'utilisation de MQTT et OpenHAB, et vous n'avez pas besoin de faire les choses exactement comme je l'ai fait. Le contrôleur utilisé pour contrôler la maison modèle peut être une version d'Arduino, un Raspberry Pi ou même un Sparkcore. Les capteurs DIY peuvent être un Arduino ou un ESP8266 autonome. La seule contrainte est que les données du capteur doivent être publiées sur le courtier MQTT d'une manière ou d'une autre. Si vous disposez d'une clé USB Z-wave sur l'installation OpenHAB, vous pouvez utiliser OpenHAB comme pont Z-wave vers MQTT et utiliser des capteurs Z-wave pour la détection de porte.

Même les capteurs d'ouverture/fermeture de Wink pourraient être utilisés différemment. Si vous ne rootez pas le Wink Hub, vous pouvez utiliser l'API Wink pour récupérer l'état du capteur et les publier sur OpenHAB, ou les publier directement via MQTT. Cela nécessite d'utiliser le serveur Wink, mais cela supprime la contrainte d'un hub rooté.

Donc, beaucoup de façons de faire les choses différemment. J'ai tendance à utiliser du matériel qui est le plus petit dénominateur commun, donc Arduino et des boîtes en carton.

Code

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

smarthome_yun.inoTexte brut

// 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, OUTPUT); //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..."); retard (5000); } Serial.println("ethernet OK"); keepalivetime=millis(); while (client.connect("smarthouse") !=1) { Serial.println("Error connecting to MQTT"); //delay(3000); retard (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(); retard (5000); while (client.connect("smarthouse") !=1) { digitalWrite(statusPin, LOW); Serial.println("Error connecting to MQTT"); retard (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

/*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(); retard (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 }

Schémas