Fysieke domotica-interface

Over dit project

Zie de twee video's hieronder voor een korte uitleg van dit project.

Een interface brengt informatie over en stelt de gebruiker in staat om dingen te controleren. De meeste domotica-platforms vertrouwen op een "virtuele interface". Je haalt een smartphone tevoorschijn en opent de app om te zien wat er met je huis aan de hand is en de lichten aan en uit te doen. Dat werkt prima als je weg bent. Maar kijken naar een virtuele weergave en het ontleden van de informatie op het scherm kost veel moeite. Het vereist focus en voelt niet intuïtief aan.

Ik wilde een "fysieke interface" maken - een klein modelhuis dat fysiek de dingen nabootst waarover ik wil weten met mijn echte huis. Dus als de garagedeur wordt geopend, wil ik dat de garagedeur op het model ook opengaat. Dit modelhuis zou op mijn salontafel kunnen staan, en ik kan er een blik op werpen om te zien of de garagedeur open is gelaten voordat ik naar bed ga. Of ik kan dit op mijn bureau op het werk hebben, verbonden met mijn huis via VPN. Als ik op mijn werk ben, kan ik er een blik op werpen om te zien of de voordeur open staat. Deze fysieke interface kan zo creatief of praktisch zijn als ik hem maak.

Dus in de volgende stappen zal ik

1. Bouw een modelhuis om dingen als deurpositie, energieverbruik en of er nog licht is aan te laten zien.
2. Bouw een energiemonitor met behulp van de Open Energy Monitor Arduino-bibliotheek en voer informatie over het energieverbruik door naar het modelhuis en naar OpenHAB
3. Geef een aantal manieren om de deur-/raampositie naar het modelhuis te sturen. Laat zien hoe de Wink Hub en de Wink "Tripper" contactsensorgegevens kunnen worden gebruikt in een doe-het-zelf domoticasysteem.
4. Gebruik Wink en Arduino om outputs uit te voeren, zoals het openen/sluiten van de eigenlijke garagedeur of het in- en uitschakelen van lichten.

Het modelhuis heeft enkele servo's en LED's die zijn aangesloten op een Arduino-controller. Deze controller is geabonneerd op MQTT-berichten die deurposities en energieverbruik aangeven, en stuurt de servo's dienovereenkomstig aan. Hetzelfde idee met de LED die aangeeft of een lamp aan of uit is. Er zijn een paar opties om deze sensorinformatie naar de MQTT-makelaar te krijgen, dus ik zal dat in latere stappen uitleggen. In het midden van dit alles is een Raspberry Pi met een MQTT-makelaar (Mosquitto) en OpenHAB. Hoewel OpenHAB niet nodig is om het modelhuis te runnen, is het wel nodig om de interface voor de smartphone-app te bieden en bewaking en bediening op afstand mogelijk te maken. Alleen omdat ik een fysieke interface wil, wil nog niet zeggen dat ik klaar ben om de virtuele weg te gooien.

Het modelhuis heeft ook twee knoppen. Een van de knoppen schakelt een zigbee-gloeilamp aan/uit. De andere knop opent en sluit de garagedeur (op het ECHTE huis).

Deel 1:Woningbouw

1) Modelwoning bouwen

2) Bedieningsopties, bedrading en code

Deel 2:Ingangen (sensoren)

3) Sensor:Energiemonitor

4) Sensor:doe-het-zelf sensorknooppuntoptie

5) Sensor:Wink Hub &Tripper-contactsensor

Deel 3:Uitgangen

6) Lichten

7) Garagedeuropener

Stap 1:Modelbouw woning

Het is niet mijn bedoeling dat deze stap prescriptief is. Ik ben behoorlijk amateur als het op kunst en kunstnijverheid aankomt, dus ik zal gewoon laten zien hoe ik mijn modelhuis heb gebouwd. Je zult het willen bouwen om op je eigen woning te lijken en de dingen weer te geven waar je om geeft. Hier is veel ruimte voor creativiteit. Sommige componenten in deze afbeelding (zoals de stroomtransformator) zullen in latere stappen worden gebruikt.

Onderdelen :

• (1) Doos. Het is aan jou hoe groot en in welke verhoudingen.
• (3) Tower Pro SG90-servo http://www.dx.com/p/towerpro-sg90-9g-mini-servo-w...
• (2) kleine scharnieren http://www.homedepot.com/p/Stanley-National-Hardw...
• (sommige) Zelfklevend materiaal. Ik gebruikte dubbelklevende lijmen van 3M haken.
• Arduino Yun of Arduino Uno met Ethernet-schild.
• Knoppenhttp://www.radioshack.com/mini-spst-1-5-amp-moment...
• Spullen die in huis liggen

Dak

Ik knipte een van de zijflappen van de doos uit en bevestigde deze aan de andere (nog steeds bevestigde) zijflap om een ​​dak te vormen. Ik gebruikte een kleine doos om een ​​structuur voor de juiste hoek te bieden, en ondersteunde het later beter met een Lego-stukje. Je kunt waarschijnlijk gewoon alles gebruiken wat je in huis hebt om deze rechte hoek te maken.

Deuren / Ramen

Snijd de gaten voor deuren die u wilt laten zien. Bevestig een of twee scharnieren aan de deur met dubbelzijdig plakband en bevestig aan het huis. Ik weet het, niets bijzonders, dus voel je vrij om te improviseren met wat je in huis hebt. Ik gebruikte 3M dubbelzijdige schuimlijmen, het soort dat met haken wordt geleverd. Deze schuimkleefstrips heb ik ook gebruikt om de servomotoren te monteren. Voor de garagedeur beweegt de servomotorarm de garagedeur open en de zwaartekracht sluit de garagedeur. Voor de voordeur moest ik een touwtje aan de scharnierende deur bevestigen zodat de servo-arm de deur kan openen. Het gele Lego-stukje dat je ziet, is er om de servo van het scharnier af te zetten.

Energiemeter

Niets speciaals. Knip gewoon een pijlachtig ding uit en bevestig het aan de servo-arm. Knip een vaag struikachtige vorm uit en markeer deze met een kilowattschaal, en plaats de servomotor met wrijving op de doos met de struik ertussen.

Boven de servo voor energieverbruik heb ik een rode LED geplakt.

Ik heb ook twee knoppen om de lichten en de garagedeur te bedienen. Dit zijn tijdelijke knoppen. De knopen zijn aan de buitenkant voorzien van schroefdraad met een moer om ze tegen de kartonnen dooswand te houden. Aan de andere kant zitten de metalen contacten om draden op te solderen.

Stap 2:Woningbouw - Draden &Code

Bekabeling

Hier is het bedradingsschema. Ik heb een behoorlijk grote puinhoop gemaakt van de bedrading in de doos. Als je liever gewoon weet welke draden op welke pinnen zitten:

• status-pin-LED:7
• verlichting indicator LED:4
• Servo 1 (voordeur):3
• Servo 2 (garagedeur):5
• Servo 3 (struik van energieverbruik):6
• Knop 1 (Licht aan/uit):8
• Knop 2 (garagedeur open/dicht):9

Controlleropties

Je kunt gebruiken waar je je prettig bij voelt en wat je bij de hand hebt. Een goedkopere optie ($ 20) is om een ​​Arduino Uno-kloon en ethernet-schild te gebruiken. Ik begon daarmee, maar dat bond me vast aan de ethernetkabel. Dus schakelde ik het over naar een Arduino Yun ($ 65). Veel duurder, maar gaf me ook de vrijheid om wifi te gebruiken. De Yun was heel gemakkelijk te gebruiken. Jij eigenlijk:

1. Verbind de Yun via ethernet met je router
2. Navigeer naar de webpagina van Yun
3. Stel wachtwoorden en statische IP in op uw router
4. Download de Yun-schets

Hieronder vindt u de schetsen voor zowel een Arduino Uno als Arduino Yun. Ze lijken veel op elkaar, en behalve de ethernetbrug die in de Yun wordt gebruikt, kun je de Yun-code vrijwel naar de Uno kopiëren. Nadat ik de overstap naar de Yun had gemaakt, heb ik de twee bedieningsknoppen toegevoegd. Als gevolg hiervan heeft de Uno-schets die knoppen niet.

De video in de eerste stap toont de Arduino Yun. Hier is een video met het Uno- en ethernet-schild. Toen deze video werd gemaakt, had ik de twee knoppen nog niet geïnstalleerd, maar de rest werkt hetzelfde.

Stap 3:Sensor:Energiemonitor

Nu we een fysieke interface hebben die het energieverbruik kan weergeven, moeten we een sensorknooppunt bouwen om het energieverbruik van het huis te lezen en dat verbruik te publiceren naar de MQTT-makelaar. Er zijn een paar manieren om dit te doen. Ik gebruik een Arduino Yun. Het is de minst gecompliceerde methode, maar niet de goedkoopste. Als je wilt, kun je een Arduino Uno, ethernet-schild en een draadloze router gebruiken om als wifi-brug te fungeren. Of u kunt een Pi gebruiken met het Open Energy Monitor-pakket. Ik zal alleen de Yun-methode behandelen.

Ik gebruik een stroomtransformator van $ 7 van ebay. De 100A-versie van de Yhdc SCT-013-000 vindt u hier. Sluit het aan volgens het bedradingsschema hierboven en upload de Arduino Yun-schets onderaan deze stap. Zorg ervoor dat u de code wijzigt met uw MQTT-broker IP-adres. Deze pagina voor de bibliotheek van de Open Energiemonitor is een goede referentie. Dit zijn de ideale componentwaarden.

• Belastingsweerstand =33 ohm
• Spanningsdelerweerstand =10k ohm
• Condensator =10uF

De foto van mijn energiemonitor komt niet echt overeen met het schakelschema omdat ik die exacte componenten niet bij de hand had. Ik moest twee weerstanden van 68 ohm parallel gebruiken omdat ik de lastweerstand van 33 ohm niet had. En ik had geen condensator van 10uF voor het gelijkrichtercircuit, dus gebruikte ik in plaats daarvan twee condensatoren van 22uF. De serie-equivalentcapaciteit is dichtbij genoeg.

Bevestig de stroomtransformator op een van de inkomende fasen van je huis. Ik had maar één transformator van 100 A, dus ik bewaak maar één van de fasen. Uiteindelijk zou ik graag meer transformatoren willen hebben om het andere been van de inkomende stroom en ook de vertakte circuits te bewaken. Met behulp van een echte ampèremeter, las mijn doe-het-zelf-opstelling altijd 1 ampère boven de ampèremeter over verschillende ampèrewaarden (zie de 5e afbeelding hierboven). Vrij eenvoudig om die extra versterker er gewoon van af te trekken.

OpenHAB

Aangezien de gegevens binnenkomen, kunnen we ze net zo goed op OpenHAB weergeven, zodat de gegevens in een grafiek kunnen worden weergegeven. Hier is de relevante OpenHAB-configuratie.

Itemdefinitie

Aantal itm_smarthome_energy_amps "Energie (ampère) [%.1f]" {mqtt="<[mymosquitto:2853:state:default]"}

Aantal itm_smarthome_energy_watts "Energie (Watt) [ %.1f]" {mqtt="<[mymosquitto:2852:state:default]"}

Sitemap

Text label="Energy" icon="firstfloor"
{

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

 Text item=itm_smarthome_energy_watts

 Grafiek item=itm_smarthome_energy_watts period=h refresh=5000 } //Frame energieverbruik

}//Text label="Energie"

Persistentie

Omdat we grafieken gebruiken, moeten we een soort persistentiestrategie voor het energieverbruik definiëren. RRD4J is het gemakkelijkst te gebruiken, dus hier is wat ik heb voor "/openhab/configurations/persistence/rrd4j.persist".

Strategieën {
 // voor rrd-diagrammen hebben we elke minuut een cron-strategie nodig:"0 * * * * ?"}

Items { DemoSwitch,NoOfLights,Window_GF_Toilet,Heating* :strategy =everyChange, everyMinute, restoreOnStartup // laten we alleen temperatuurwaarden opslaan in rrd Temperature*,Weather_Chart* :strategy =everyMinute, restoreOnStartup itm_smarthome_energy_watts :strategy =everyUpdate}

Energiemonitorscherm

Stap 4:Sensor:doe-het-zelf draadloze sensorknooppunten

Er zijn een paar opties voor draadloze open/dicht-sensoren.

In een van mijn eerdere projecten gebruikte ik een draadloze transceiver van $ 5 om sensorgegevens via een MQTT-gateway te verzenden. Ik gebruik dit project nog steeds om de status van de garagedeur naar OpenHAB te krijgen, en in de demovideo geeft de garagedeur van het modelhuis mijn werkelijke status van de garagedeur weer. De gedetailleerde code en het circuit vindt u in deze stap als u deze wilt gebruiken. Het is een beetje lelijk, maar het staat in de garage waar niemand het zal merken.

Er is ook een lichtsensor die ik gebruik om aan te geven of er een lampje is blijven branden. Dit komt ook uit die vorige Instructable die in deze stap wordt beschreven. Het maakt deel uit van de Uber-sensor die een fotoweerstand gebruikt om informatie over de helderheid draadloos terug te sturen naar OpenHAB. In dit geval abonneer ik me gewoon op het MQTT-onderwerp dat het lichtniveau aangeeft.

Ik heb ook een op batterijen werkende reed-schakelaarsensor gemaakt die dezelfde draadloze transceiver en gateway gebruikt in die vorige Instructable. Het ziet er echter niet erg goed uit. Ik kan het om esthetische redenen niet echt op een binnendeur of raam gebruiken. Dus om dit probleem te verhelpen, gebruik ik mooiere reed-schakelaarsensoren van consumentenkwaliteit van Wink. Wat ons naar de volgende stap brengt.

Stap 5:Sensor:Wink Hub

Ik kwam toevallig op deze blogpost van een vroege Wink Hub-gebruiker die een manier vond om de hub te rooten om toegang te krijgen tot een PHP-exploit. Met deze exploit kun je een "aprontest"-hulpprogramma uitvoeren om dingen te controleren die zijn gekoppeld aan de Wink Hub. Met deze methode heb ik lampen kunnen bedienen vanuit de OpenHAB-interface.

Het meest interessante voordeel van het rooten van de Wink Hub is dat het u lokale . geeft controle over lichten en sensorstatus zonder toegang tot de Wink-server. De Wink Hub en Wink API moeten altijd naar het internet gaan om contact op te nemen met de Wink-server om de verlichting te regelen of de sensorstatus te krijgen. Met deze PHP-exploit kunnen verlichting en sensorbewerkingen nu in uw lokale LAN worden gehouden. Dat is geweldig.

Ik heb onderaan deze stap een PHP-script toegevoegd. Als je dit bestand niet kunt openen, probeer dan deze link. Dit script draait op de Raspberry Pi en peilt de Wink Hub naar de status van twee Wink Tripper-reedschakelaars. Deze status wordt via de REST API naar OpenHAB gestuurd. OpenHAB zal dan MQTT-onderwerpen voor deze deurposities publiceren. De controller voor het modelhuis opent of sluit vervolgens de deuren door zich te abonneren op deze deurpositie-onderwerpen.

De drie OpenHAB-configuratiebestanden (items, sitemap en regels) die in deze stap zijn bijgevoegd, zijn nodig om alles te laten werken. Ze definiëren de contactitems waarmee het pollingscript interageert via de REST-interface. Er is ook een voorbeeldscript voor het aansturen van zigbee-gloeilampen via OpenHAB.

Scripts en configuratiebestanden.

Stap 6:Uitgang:Licht

Vanwege de volgorde waarin ik de configuratiebestanden heb behandeld, boden de vorige stappen vrijwel alles wat nodig was om een ​​"verbonden gloeilamp" te bedienen via zowel de fysieke interface als de OpenHAB-interface. De lichten kunnen elk licht zijn dat de Wink-hub ondersteunt. Momenteel heb ik dit getest met de Cree Connected Bulb en de GE Wink-lampen. Beide werken zoals verwacht. Ik gooi hier gewoon deze video die beter laat zien hoe de lichtsensor en knoppen de slimme lamp bedienen.

Stap 7:Uitgang:Garagedeuropener

De configuratiebestanden in stap 5 bevatten de meeste van de benodigde OpenHAB-items voor het besturen van een garagedeur. Maar je hebt nog steeds iets nodig om de garagedeur daadwerkelijk te openen en te sluiten. Daarvoor pas ik delen van een eerdere Instructable aan. Ik heb een garagedeuropener gemaakt met deze componenten:

• Arduino-kloon ($10)
• Ethernet-schild ($7)
• Reed-estafette ($ 2)
• Reserve afstandsbediening garagedeur ($22)

De Arduino bestuurt een reed-relais door de droge contacten te openen en te sluiten. De knop van de reserve garagedeuropener is bedraad over het droge contact op het reed-relais. Sluit pin 5 en GND van de Arduino aan op de twee spoelpinnen (twee buitenste pinnen) van het reed-relais en de binnenste relaispinnen op de knop op de afstandsbediening van de garagedeur.

De Arduino abonneert zich op een MQTT-onderwerp en wacht op de opdracht openen/sluiten. Wanneer hij dit onderwerp ziet, activeert hij het reed-relais even en sluit de "knop" op de afstandsbediening van de extra garagedeur. De Arduino-schets is hieronder bijgevoegd. Voeg bovendien de "garage_monitor_rules.txt" toe aan uw regelbestand. Dit is nodig naast de regels die in stap 5 zijn bijgevoegd. Als u de ultrasone sensormethode niet gebruikt die ik heb gebruikt, is dit het onderdeel dat u zou moeten wijzigen om aan uw wijziging te voldoen.

Als je garagedeur vrij rustig is of als je een soort audio-aankondiging in een ander deel van het huis wilt voor wanneer de garagedeur opengaat, kan de toegevoegde regel hierboven een audiobestand afspelen. Je kunt het ongeveer een minuut of dertig in de eerste videodemo horen.

Stap 8:Andere gedachten

De beslissingen die in dit project worden genomen, weerspiegelen de tools waar ik me prettig bij voel, de onderdelen die ik bij de hand heb en mijn prioriteiten voor hoe ik wil dat dingen werken. U hebt waarschijnlijk een andere set tools en u hebt verschillende hardwarecomponenten direct beschikbaar. Je hebt waarschijnlijk ook andere ideeën over hoe domotica zou moeten werken.

Er is veel flexibiliteit bij het gebruik van MQTT en OpenHAB, en je hoeft de dingen niet precies te doen zoals ik het heb gedaan. De controller die wordt gebruikt om het modelhuis te besturen, kan een soort Arduino, een Raspberry Pi of zelfs een Sparkcore zijn. De doe-het-zelf sensoren kunnen een Arduino of een standalone ESP8266 zijn. De enige beperking is dat de sensorgegevens op de een of andere manier naar de MQTT-makelaar moeten worden gepubliceerd. Als je een USB Z-wave-stick op de OpenHAB-installatie hebt, kun je OpenHAB gebruiken als een Z-wave naar MQTT-brug en Z-wave-sensoren gebruiken voor deurdetectie.

Zelfs de Wink open / close-sensoren kunnen anders worden gedaan. Als je de Wink Hub niet root, kun je de Wink API gebruiken om de sensorstatus te pakken en deze naar OpenHAB te posten, of post ze rechtstreeks via MQTT. Dit vereist het gebruik van de Wink Server, maar het verwijdert de beperking van een geroote hub.

Dus veel manieren om dingen anders te doen. Ik heb de neiging om hardware te gebruiken die de kleinste gemene deler is, dus Arduino en kartonnen dozen.

Code

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

smarthome_yun.inoPlatte tekst

// Eric Tsai// 2015-04-13// Arduino Yun-code voor het besturen van fysieke smart home-interface// Pas de namen van MQTT-onderwerpen aan zodat ze overeenkomen met uw gebruik// Wijzig het IP-adres van de MQTT-broker//new yun include#include #include #include //old ethernet include bij gebruik van ethernet shield/*#include #include #include  */#include //Ethernet shield setup/*IPAddress ip(192, 168, 2, 36);byte 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;//gebruik yunclient om te overbruggen naar netwerkYunClient yun; //equivalent van ethernet clientPubSubClient client ("192.168.1.101", 1883, callback, yun);bool conn_ok;//use LED voor het aangeven van MQTT-verbindingsstatus.int ledPin =4; // geeft lampjes aan inint statusPin =7; //geef MQTT conn status aan//servo controlint servo1Pin =3; // voordeurint servo2Pin =5; // garagedeurint servo3Pin =6; //energieverbruikmeterServo servo1; //doorServo servo2; // garagedeurServo servo3; //energyint-knop1 =8; // knop boven voordeurint knop2 =9; // knop boven garagedeur // servobediening:doelposities voor servosint servo1_target =5; // deur, gesloten servo2_target =5; // garage, gesloten servo3_target =180; //energie, 180 is "0" watt, motor achterstevoren gemonteerdint servo1_pos_cur =5;int servo2_pos_cur =5;int servo3_pos_cur =180; // 180 is "0" watt, motor achteruit gemonteerd servo1Opened =5;int servo1Gesloten =130;int servo2Opened =5;int servo2Closed =150;unsigned long servo1_time =0;unsigned long servo2_time =0;unsigned long servo3_time =0;/ /debounce op knoppen, zodat u niet spamt publishunsigned long button1_db =0;unsigned long button2_db =0;int button=0;int callback_flag =0;char buff_message[12];//--------- -------------------------------------------------- ----// MQTT terugbellen// reageer hier op MQTT-berichten//-------------------------------- ------------------------------- ongeldige callback (char * onderwerp, byte * payload, niet-ondertekende int lengte) {//convert onderwerp naar int. int mytopic =atoi (onderwerp); //Serial.print(mijnonderwerp); //converteer payload naar int payload [lengte] ='\0'; // voeg een regelretour toe zodat atof correct kan ontleden float mymsg =atof ((const char *) payload); // led if (mytopic ==2822) {if (mymsg ==1) {digitalWrite (ledPin, HIGH); } if (mymsg ==0) {digitalWrite(ledPin, LOW); } } //servo 1, voordeur if (mytopic ==2832) { if (mymsg ==1) //geopend { //Serial.println("servo1 geopend"); servo1_target =servo1Geopend; } if (mymsg ==0) //closed { //Serial.println ("servo1 closed"); servo1_target =servo1Gesloten; } //Serial.println(servo1_target); } /* // tweede garagedeursignaal "gesloten" =uit =stuur 1 "open" =aan =stuur 0 */ //servo 2, garagedeur if (mytopic ==2842) { if (mymsg ==1) / /geopend { servo2_target =servo2Opened; } if (mymsg ==0) //closed { servo2_target =servo2Closed; } //callback_flag=1; //servo3_target =mijn bericht; } // servo 3, energiemeter if (mytopic ==2852) { //message =watt // gebonden watt aan meter max &min 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)-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(); vertraging (5000); while (client.connect("smarthouse") !=1) { digitalWrite(statusPin, LOW); //Serial.println("Error connecting to MQTT"); vertraging (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, 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..."); vertraging (5000); } Serial.println("ethernet OK"); keepalivetime=millis(); while (client.connect("smarthouse") !=1) { Serial.println("Error connecting to MQTT"); //delay(3000); vertraging (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(); vertraging (5000); while (client.connect("smarthouse") !=1) { digitalWrite(statusPin, LOW); Serial.println("Error connecting to MQTT"); vertraging (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(); vertraging (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 }

Schema's