Robuuste Fysieke Interface voor Thuisautomatisering

Onderdelen en Benodigdheden

TowerPro Servo	×	1
Kleine Scharnieren	×	1
Knoppen	×	1
Arduino Yun	×	1
100A Stroomtransformator	×	1
Weerstanden en Condensatoren	×	7

Over dit Project

Bekijk de twee video's hieronder voor een snelle uitleg van dit project.

Fysieke Thuisautomatisering Interface - Interface met Echte Wereld Besturing

Een interface brengt informatie over en stelt de gebruiker in staat om dingen te besturen. De meeste thuisautomatiseringsplatformen vertrouwen op een "virtuele interface". Je haalt je smartphone eruit, opent de app om te zien wat er in je huis gebeurt, en zet lichten aan en uit. Dat werkt prima als je weg bent. Maar naar een virtuele representatie kijken en de informatie op het display parseren kost moeite. Het vereist focus, en voelt niet intuïtief.

Ik wilde een "fysieke interface" maken - een klein modelhuis dat fysiek de dingen nabootst die ik wil weten over mijn echte huis. Dus wanneer de garagedeur open gaat, wil ik dat de garagedeur op het model ook open gaat. Dit modelhuis kan op mijn salontafel staan, en ik kan ernaar kijken om te zien of de garagedeur open is gelaten voordat ik ga slapen. Of ik kan het op mijn bureau op het werk zetten, via VPN verbonden met mijn thuis. Als ik op het werk ben, kan ik ernaar kijken om te zien of de voordeur open is gelaten. Deze fysieke interface kan zo creatief of zo utilitair zijn als ik hem maak.

In de volgende stappen zal ik:

1. Een modelhuis bouwen om dingen weer te geven zoals deurpositie, energieverbruik, en of een licht is achtergelaten.
2. Een energiemonitor bouwen met de Open Energy Monitor Arduino-bibliotheek, en energiegebruiksinformatie doorsturen naar het modelhuis en naar OpenHAB.
3. Een paar manieren tonen om deur/raampositie naar het modelhuis te sturen. Laten zien hoe de Wink Hub en de Wink "Tripper" contactsensor data kunnen worden benut in een DIY-thuisautomatiseringssysteem.
4. Wink en Arduino gebruiken om outputs uit te voeren, zoals de echte garagedeur openen/sluiten of lichten aan/uit zetten.

Het modelhuis heeft enkele servos en LED's aangesloten op een Arduino-controller. Deze controller abonneert zich op MQTT-berichten die deurposities en energieverbruik aangeven, en stuurt de servos daarbij aan. Hetzelfde geldt voor de LED die aangeeft of een licht aan of uit is. Er zijn een paar opties om deze sensorinformatie naar de MQTT-broker te krijgen, dat zal ik in latere stappen detaileren. In het midden van het geheel zit een Raspberry Pi met een MQTT-broker (Mosquitto) en OpenHAB. Hoewel OpenHAB niet nodig is om het modelhuis te draaien, is het wel nodig om de interface voor de smartphone-app te bieden, en externe monitoring en besturing toe te staan. Alleen omdat ik een fysieke interface wil, betekent niet dat ik de virtuele eruit wil gooien.

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

Deel 1: Huisconstructie

Stap 1: Modelhuisconstructie

Ik bedoel deze stap niet voorschrijvend te zijn. Ik ben redelijk amateur wat betreft kunst en ambacht, dus ik zal gewoon laten zien hoe ik mijn modelhuis bouwde. Je wilt het bouwen zodat het je eigen woning weerspiegelt en de dingen reflecteert waar je om geeft. Veel ruimte voor creativiteit hier. Sommige componenten in deze afbeelding (zoals de stroomtransformator) worden in latere stappen gebruikt.

Componenten:

• (1) Doos. Het is aan jou hoe groot en wat de verhoudingen zijn.
• (3) Tower Pro SG90 servo link
• (2) kleine scharnieren link
• (enkele) Lijmmateriaal. Ik gebruikte dubbelzijdige lijm van 3M-haken.
• Arduino Yun of Arduino Uno met Ethernet shield.
• Knoppen link
• Spullen die in huis liggen

Dak

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

Deuren / Ramen

Knip de gaten voor de deuren die je wilt tonen. Bevestig een scharnier of twee aan de deur met dubbelzijdige tape en bevestig aan het huis. Ik weet, niets fancy, dus voel je vrij om te improviseren met wat je in huis hebt liggen. Ik gebruikte 3M dubbelzijdige schuimlijmstrips, de soort die bij haken hoort. Ik gebruikte deze schuimlijmstrips ook om de servomotoren te monteren. Voor de garagedeur beweegt de servo-arm de garagedeur open, en zwaartekracht sluit de garagedeur. Voor de voordeur moest ik een touwtje aan de gescharnierde deur bevestigen zodat de servo-arm de deur open kan maken. Het gele Lego-stukje dat je ziet is er om de servo van het scharnier te offsetten.

Energiemeter

Niets fancy. Knip gewoon een pijltje-achtig ding uit en bevestig het aan de servo-arm. Knip een vage struik-achtige vorm uit en markeer het met een kilowatt-schaal, en friktie-fit de servomotor op de doos met de struik ertussen.

Boven de energieverbruik-servo plakte ik een rode LED.

Ik heb ook twee knoppen om lichten en de garagedeur te besturen. Dit zijn momentanknoppen. De knoppen zijn gegeneind met een moer aan de buitenkant om het tegen de kartonnen dooswand te houden. Aan de andere zijkant zitten de metalen contacten voor draden om op te solderen.

Stap 2: Huisconstructie - Draden & Code

Bedrading

Hier is het bedradingsschema. Ik maakte een behoorlijke rommel van de bedrading in de doos. Als je liever wilt weten welke draden op welke pinnen zitten:

• Statuspin LED: 7
• Verlichtingsindicator LED: 4
• Servo 1 (voordeur): 3
• Servo 2 (garagedeur): 5
• Servo 3 (struik van energieverbruik): 6
• Knop 1 (Lichten aan/uit): 8
• Knop 2 (Garagedeur open/sluiten): 9

Controlleropties

Je kunt gebruiken wat je comfortabel vindt en wat je ter hand hebt. Een goedkopere optie ($20) is een Arduino Uno-clone en Ethernet-shield. Ik begon daarmee, maar dat hield me aan de ethernetkabel gebonden. Dus ik schakelde over naar een Arduino Yun ($65). Veel duurder, maar gaf me ook de vrijheid om WiFi te gebruiken. De Yun was echt makkelijk te gebruiken. Je doet eigenlijk:

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

Hieronder staan de sketches voor zowel een Arduino Uno als Arduino Yun. Ze zijn redelijk vergelijkbaar, en behalve de ethernet-brug die in de Yun gebruikt wordt, kun je de Yun-code vrijwel direct naar de Uno kopiëren. Na de switch naar de Yun, voegde ik de twee besturingsknoppen toe. Als gevolg heeft de Uno-sketch die knoppen niet.

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

Bestanden:

• smarthome_ethernet.ino
• smarthome_yun.ino

Deel 2: Ingangen (Sensoren)

Stap 3: Sensor: Energiemonitor

Nu we een fysieke interface hebben die het energieverbruik kan tonen, moeten we een sensorknooppunt bouwen om het energieverbruik van het huis uit te lezen en dat verbruik te publiceren naar de MQTT-broker. Er zijn een paar manieren om dit te doen. Ik gebruik een Arduino Yun. Het is de minst ingewikkelde methode, maar niet de goedkoopste. Als je wilt, kun je een Arduino Uno, Ethernet-shield, en een draadloze router gebruiken die als WiFi-brug fungeert. Of je kunt een Pi met het Open Energy Monitor-pakket gebruiken. Ik zal hier alleen de Yun-methode behandelen.

Ik gebruik een $7 stroomtransformator van eBay. Je kunt de 100A-versie van de Yhdc SCT-013-000 hier vinden. Bedraad het volgens het bedradingsschema hierboven, en upload de Arduino Yun-sketch aan de onderkant van deze stap. Zorg ervoor dat je de code wijzigt met het IP-adres van je MQTT-broker. Deze pagina voor de Open Energy Monitor-bibliotheek is een goede referentie. Hier zijn de ideale componentwaarden.

• Belastingweerstand = 33 ohm
• Spanningsdeler-weerstand = 10k ohm
• Condensator = 10uF

De foto van mijn energiemonitor komt niet echt overeen met het schakelingsschema omdat ik die exacte componenten niet ter hand had. Ik moest twee 68 ohm weerstanden in parallel gebruiken omdat ik de 33 ohm belastingweerstand niet had. En ik had geen 10uF condensator voor de gelijkrichterschakeling, dus ik gebruikte twee 22uF condensatoren in plaats daarvan. De serie-equivalente capaciteit is dicht genoeg.

Bevestig de stroomtransformator op een van de inkomende fasen van je huis. Ik had maar één 100A-transformator, dus ik monitor maar één van de fasen. Uiteindelijk zou ik graag meer transformators willen om de andere been van de inkomende stroom en ook de takcircuits te monitoren. Met een echte amperemeter las mijn DIY-opstelling altijd 1 ampère boven de amperemeter over verschillende amperemetingen (zie 5e afbeelding hierboven). Een simpele kwestie om die extra ampère af te trekken.

OpenHAB

Omdat we de data binnenkrijgen, kunnen we het ook op OpenHAB tonen zodat de data gegrafiseerd kan worden. Hier is de relevante OpenHAB-configuratie.

Item Definitie

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

Sitemap

Text label="Energie" icon="firstfloor" {
  Frame label="Energieverbruik" {
    Text item=itm_smarthome_energy_amps
    Text item=itm_smarthome_energy_watts
    Chart item=itm_smarthome_energy_watts period=h refresh=5000
  }
}

Persistentie

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

Strategies {
  // voor rrd grafieken, hebben we een cron-strategie nodig
  everyMinute : "0 * * * * ?"
}
Items {
  DemoSwitch,NoOfLights,Window_GF_Toilet,Heating* : strategy = everyChange, everyMinute, restoreOnStartup
  // laat ons alleen temperatuurwaarden in rrd opslaan
  Temperature*,Weather_Chart* : strategy = everyMinute, restoreOnStartup
  itm_smarthome_energy_watts : strategy = everyUpdate
}

Energiemonitor Scherm

Bestand: energy_monitor_yun.ino

Stap 4: Sensor: DIY Draadloze Sensorknooppunten

Er zijn een paar opties voor draadloze open/dichtsensoren.

In een van mijn eerdere projecten gebruikte ik een $5 draadloze transceiver om sensordata over een MQTT-gateway te sturen. Ik gebruik dit project nog steeds om de garagedeurstatus naar OpenHAB te krijgen, en in de demovideo is dat eigenlijk hoe de garagedeur van het modelhuis mijn echte garagedeurstatus weerspiegelt. De gedetailleerde code en schakeling vind je in deze stap als je het wilt gebruiken. Het is een beetje lelijk, maar het zit in de garage waar waarschijnlijk niemand het zal opmerken.

Er is ook een lichtsensor die ik gebruik om aan te geven of een licht is achtergelaten. Dit komt ook uit dat eerdere Instructable gedetailleerd in deze stap. Het is onderdeel van de Uber-sensor die een fotoweerstand gebruikt om helderheidsinformatie 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 batterijgevoede reed-switchsensor gemaakt die dezelfde draadloze transceiver en gateway gebruikt als in dat eerdere Instructable. Het is echter niet erg mooi. Ik kan het niet echt op een interieurdeur of raam gebruiken om esthetische redenen. Om dit probleem op te lossen, gebruik ik mooier uitziende consumer-grad reed-switchsensoren van Wink. Wat ons leidt naar de volgende stap.

Stap 5: Sensor: Wink Hub

Ik kwam een blogpost tegen 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"-utility draaien om dingen te besturen die met de Wink Hub zijn gekoppeld. Met deze methode kon ik lichten besturen vanuit de OpenHAB-interface.

Het meest interessante voordeel van het rooten van de Wink Hub is dat het je lokale controle geeft over lichten en sensorstatus zonder toegang te hoeven hebben tot de Wink-server. De Wink Hub en Wink API moeten altijd naar het internet om de Wink-server te bereiken voor verlichtingsbesturing of sensortatus op te halen. Nu, met deze PHP-exploit, kunnen verlichtings- en sensoroperaties op je lokale LAN blijven. Dat is geweldig.

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

De drie OpenHAB-configuratiebestanden (items, sitemap, en rules) die in deze stap zijn bijgevoegd, zijn nodig om alles werkend te krijgen. Ze definiëren de contact-items waarmee het pollingscript interacteert via de REST-interface. Er is ook een voorbeeldscript voor het besturen van een Zigbee-lamp via OpenHAB.

Scripts en configuratiebestanden:

• sitemap.txt
• rules.txt
• items.txt
• demo_1_general.sh
• polling.php

Stap 6: Uitgang: Lichten

Vanwege de volgorde waarin ik de configuratiebestanden heb behandeld, hebben de vorige stappen vrijwel alles geleverd wat nodig is om een "verbonden lamp" te besturen via zowel de fysieke interface als de OpenHAB-interface. De lichten kunnen elke lamp zijn die de Wink hub ondersteunt. Momenteel heb ik dit getest met de Cree Connected Bulb en de GE Wink-lichten. Beide werken zoals verwacht. Ik plaats gewoon deze video hier die beter laat zien hoe de lichtsensor en knoppen de slimme lamp besturen.

Stap 7: Uitgang: Garagedeuropener

De configuratiebestanden die in Stap 5 zijn gegeven, bevatten de meeste benodigde OpenHAB-items voor het besturen van een garagedeur. Maar je hebt nog steeds iets nodig om de garagedeur daadwerkelijk te openen en sluiten. Voor dat wijzig ik onderdelen van een eerdere Instructable. Ik maakte een garagedeuropener met deze componenten:

• Arduino-clone ($10)
• Ethernet-shield ($7)
• Reed-relais ($2)
• Reserve garagedeur-afstandsbediening ($22)

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

De Arduino abonneert zich op een MQTT-onderwerp en wacht op het open/sluit-commando. Wanneer het dit onderwerp ziet, activeert het het reed-relais momentaan, wat de "knop" op de reserve garagedeur-afstandsbediening sluit. De Arduino-sketch is hieronder bijgevoegd. Daarnaast voeg de "garage_monitor_rules.txt" toe aan je regelsbestand. Dit is nodig naast de regels die in Stap 5 zijn bijgevoegd. Als je de ultrasone-sensormethode die ik gebruikte niet gebruikt, is dit het deel dat je moet wijzigen om aan je aanpassing te voldoen.

Als je garagedeur bestwel stil is of je een soort audio-aankondiging in een ander deel van het huis wilt voor wanneer de garagedeur open gaat, kan de bovenstaande regel een audiobestand afspelen. Je kunt het horen in de eerste demovideo ongeveer op een minuut dertig.

Bestanden:

• garage_monitor_rules.txt
• grage_opener.ino

Stap 8: Andere Gedachtes

De keuzes in dit project weerspiegelen de tools waarmee ik comfortabel ben, de onderdelen die ik ter hand heb, en mijn prioriteiten voor hoe ik wil dat dingen werken. Je hebt waarschijnlijk een andere set tools, en je hebt andere hardwarecomponenten beschikbaar. Je hebt waarschijnlijk ook andere ideeën over hoe thuisautomatisering zou moeten werken.

Er is veel flexibiliteit bij het gebruik van MQTT en OpenHAB, en je hoeft dingen niet precies zo te doen als ik. De controller die het modelhuis bestuurt, kan een smaken van Arduino zijn, een Raspberry Pi, of zelfs een Sparkcore. De DIY-sensoren kunnen een Arduino zijn of een zelfstandige ESP8266. De enige beperking is dat de sensordata op een of andere manier naar de MQTT-broker gepubliceerd moet worden. Als je een USB Z-wave-stick op de OpenHAB-installatie hebt, kun je OpenHAB als een Z-wave-naar-MQTT-brug gebruiken, en Z-wave-sensoren voor deurdectie benutten.

Zelfs de Wink open/dichtsensoren kunnen anders gedaan worden. Als je de Wink Hub niet root, kun je de Wink API gebruiken om de sensorstatus op te halen en naar OpenHAB te posten, of ze direct via MQTT te posten. Dit vereist het gebruik van de Wink-server, maar verwijdert de beperking van een geroot hub.

Dus, veel manieren om dingen anders te doen. Ik neig ertoe om hardware te gebruiken die de laagste gemeenschappelijke noemer is, dus Arduino en kartonnen dozen.

Code

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

smarthome_yun.ino

// Eric Tsai
// 2015-04-13
// Arduino Yun code voor het besturen van fysieke slimme huisinterface
// Wijzig MQTT-onderwerpnamen om aan je gebruik te voldoen
// Wijzig MQTT-broker IP-adres

#include <Bridge.h>
#include <YunClient.h>
#include <PubSubClient.h>
#include <Servo.h>

unsigned long keepalivetime=0;
unsigned long MQTT_reconnect=0;

YunClient yun;
PubSubClient client("192.168.1.101", 1883, callback, yun);
bool conn_ok;

int ledPin = 4;
int statusPin = 7;

int servo1Pin = 3;
int servo2Pin = 5;
int servo3Pin = 6;

Servo servo1;
Servo servo2;
Servo servo3;

int button1 = 8;
int button2 = 9;

int servo1_target = 5;
int servo2_target = 5;
int servo3_target = 180;

int servo1_pos_cur = 5;
int servo2_pos_cur = 5;
int servo3_pos_cur = 180;

int 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;

unsigned long button1_db = 0;
unsigned long button2_db = 0;
int button = 0;
int callback_flag = 0;
char buff_message[12];

void callback(char* topic, byte* payload, unsigned int length) {
  int mytopic = atoi(topic);
  payload[length] = '\0';
  float mymsg = atof((const char *) payload);

  if (mytopic == 2822) {
    if (mymsg == 1) digitalWrite(ledPin, HIGH);
    if (mymsg == 0) digitalWrite(ledPin, LOW);
  }

  if (mytopic == 2832) {
    if (mymsg == 1) servo1_target = servo1Opened;
    if (mymsg == 0) servo1_target = servo1Closed;
  }

  if (mytopic == 2842) {
    if (mymsg == 1) servo2_target = servo2Opened;
    if (mymsg == 0) servo2_target = servo2Closed;
  }

  if (mytopic == 2852) {
    if (mymsg > 6000) mymsg = 6000;
    if (mymsg < 0) mymsg = 0;
    servo3_target = 180-((1-((6000-mymsg)/6000))*180)-25;
    callback_flag=1;
  }
}

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(statusPin, OUTPUT);
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  digitalWrite(ledPin, HIGH);
  Bridge.begin();
  client.connect("yun smarthome");
  client.publish("watch", "Smart Home Connected!");
  keepalivetime = millis();
  MQTT_reconnect = millis();
  client.subscribe("2822");
  client.subscribe("2832");
  client.subscribe("2842");
  client.subscribe("2852");
  digitalWrite(ledPin, LOW);
  servo1.attach(servo1Pin); servo1.write(90);
  servo2.attach(servo2Pin); servo2.write(90);
  servo3.attach(servo3Pin); servo3.write(5);
}

void loop() {
  client.loop();

  if ((millis() - servo1_time) > 20) {
    if (servo1_pos_cur > servo1_target) servo1_pos_cur--;
    if (servo1_pos_cur < servo1_target) servo1_pos_cur++;
    servo1.write(servo1_pos_cur);
    servo1_time = millis();
  }

  if ((millis() - servo2_time) > 20) {
    if (servo2_pos_cur > servo2_target) servo2_pos_cur--;
    if (servo2_pos_cur < servo2_target) servo2_pos_cur++;
    servo2.write(servo2_pos_cur);
    servo2_time = millis();
  }

  if ((millis() - servo3_time) > 20) {
    if (servo3_pos_cur > servo3_target) servo3_pos_cur--;
    if (servo3_pos_cur < servo3_target) servo3_pos_cur++;
    servo3.write(servo3_pos_cur);
    servo3_time = millis();
  }

  if (callback_flag == 1) {
    callback_flag = 0;
    dtostrf(servo3_target, 4, 5, buff_message);
    client.publish("watch", buff_message);
  }

  button = digitalRead(button1);
  if (button == 0) {
    if (((millis() - button1_db) > 3000) || (button1_db > millis())) {
      button1_db = millis();
      client.publish("2862", "button1 yaya");
    }
  }

  button = digitalRead(button2);
  if (button == 0) {
    if (((millis() - button2_db) > 3000) || (button2_db > millis())) {
      button2_db = millis();
      client.publish("2872", "button2 yaya");
    }
  }

  if ((millis() - MQTT_reconnect) > 60000) {
    conn_ok = client.connected();
    if (conn_ok == 1) digitalWrite(statusPin, HIGH);
    else digitalWrite(statusPin, LOW);

    if (conn_ok == 0) {
      client.disconnect();
      delay(5000);
      while (client.connect("smarthouse") != 1) {
        digitalWrite(statusPin, LOW);
        delay(4000);
      }
      digitalWrite(statusPin, HIGH);
    }
    MQTT_reconnect = millis();
    client.publish("watch", "smart home heartbeat!");
  }
}

smarthome_ethernet.ino

// Eric Tsai
// 2015-04-1
// Arduino Uno w/ Ethernet, code voor fysieke slimme huisinterface

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>
#include <Servo.h>

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;
bool conn_ok;

int ledPin = 4;
int statusPin = 7;

int servo1Pin = 3;
int servo2Pin = 5;
int servo3Pin = 6;

Servo servo1;
Servo servo2;
Servo servo3;

int servo1_target = 5;
int servo2_target = 5;
int servo3_target = 180;

int servo1_pos_cur = 5;
int servo2_pos_cur = 5;
int servo3_pos_cur = 180;

int 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;

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.println("received MQTT");
  int mytopic = atoi(topic);
  payload[length] = '\0';
  float mymsg = atof((const char *) payload);

  if (mytopic == 2822) {
    if (mymsg == 1) digitalWrite(ledPin, HIGH);
    if (mymsg == 0) digitalWrite(ledPin, LOW);
  }

  if (mytopic == 2832) {
    if (mymsg == 1) {
      Serial.println("servo1 opened");
      servo1_target = servo1Opened;
    }
    if (mymsg == 0) {
      Serial.println("servo1 closed");
      servo1_target = servo1Closed;
    }
    Serial.println(servo1_target);
  }

  if (mytopic == 2842) {
    if (mymsg == 1) servo2_target = servo2Opened;
    if (mymsg == 0) servo2_target = servo2Closed;
  }

  if (mytopic == 2852) {
    if (mymsg > 6000) mymsg = 6000;
    if (mymsg < 0) mymsg = 0;
    servo3_target = 180-((1-((6000-mymsg)/6000))*180);
  }
}

void setup() {
  Serial.begin(9600);
  Serial.println("starting");
  pinMode(ledPin, OUTPUT);
  pinMode(statusPin, OUTPUT);
  digitalWrite(ledPin, HIGH);

  while (Ethernet.begin(mac) != 1) {
    Serial.println("Error getting IP address via DHCP, trying again...");
    delay(5000);
  }
  Serial.println("ethernet OK");
  keepalivetime = millis();

  while (client.connect("smarthouse") != 1) {
    Serial.println("Error connecting to MQTT");
    delay(4000);
  }
  MQTT_reconnect = millis();
  Serial.println("setup complete");
  client.publish("smarthouse", "hello world");

  client.subscribe("2822");
  client.subscribe("2832");
  client.subscribe("2842");
  client.subscribe("2852");
  digitalWrite(ledPin, LOW);

  servo1.attach(servo1Pin); servo1.write(90);
  servo2.attach(servo2Pin); servo2.write(90);
  servo3.attach(servo3Pin); servo3.write(5);
}

void loop() {
  client.loop();

  if ((millis() - servo1_time) > 20) {
    if (servo1_pos_cur > servo1_target) servo1_pos_cur--;
    if (servo1_pos_cur < servo1_target) servo1_pos_cur++;
    servo1.write(servo1_pos_cur);
    servo1_time = millis();
  }

  if ((millis() - servo2_time) > 20) {
    if (servo2_pos_cur > servo2_target) servo2_pos_cur--;
    if (servo2_pos_cur < servo2_target) servo2_pos_cur++;
    servo2.write(servo2_pos_cur);
    servo2_time = millis();
  }

  if ((millis() - servo3_time) > 20) {
    if (servo3_pos_cur > servo3_target) servo3_pos_cur--;
    if (servo3_pos_cur < servo3_target) servo3_pos_cur++;
    servo3.write(servo3_pos_cur);
    servo3_time = millis();
  }

  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");
    }

    if (conn_ok == 0) {
      client.disconnect();
      delay(5000);
      while (client.connect("smarthouse") != 1) {
        digitalWrite(statusPin, LOW);
        delay(4000);
      }
      digitalWrite(statusPin, HIGH);
    }
    MQTT_reconnect = millis();
    client.publish("smarthouse", "heartbeat every minute!");
  }
}

energy_monitor_yun.ino

/* Eric Tsai
   2015-04-22
   Arduino Yun code voor publiceren van energieverbruik naar MQTT-broker
   Wijzig "PubSubClient client" voor je broker IP-adres
*/

#include <Bridge.h>
#include <YunClient.h>
#include <PubSubClient.h>
#include "EmonLib.h"

int LED = 3;
EnergyMonitor emon1;

unsigned long MQTT_reconnect = 0;
unsigned long read_energy = 0;
double Irms;
bool conn_ok;

YunClient yun;
PubSubClient client("192.168.1.101", 1883, callback, yun);

void callback(char* topic, byte* payload, unsigned int length) {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
}

void setup() {
  pinMode(LED, OUTPUT);
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  Bridge.begin();
  client.connect("yun_energy");
  client.publish("watch", "Energy Monitor Connected!");
  client.subscribe("yun_energy");
  digitalWrite(LED, HIGH);
  delay(3000);
  digitalWrite(LED, LOW);
  emon1.current(5, 60);
}

void loop() {
  char buff_message[12];
  float value;
  client.loop();

  Irms = emon1.calcIrms(1480);

  if (millis() - read_energy > 10000) {
    value = Irms;
    dtostrf(value, 4, 5, buff_message);
    client.publish("2853", buff_message);
    read_energy = millis();

    value = Irms * 115;
    dtostrf(value, 4, 5, buff_message);
    client.publish("2852", buff_message);
  }

  if ((millis() - MQTT_reconnect) > 60000) {
    conn_ok = client.connected();
    if (conn_ok == 1) digitalWrite(LED, HIGH);
    else digitalWrite(LED, LOW);

    if (conn_ok == 0) {
      client.disconnect();
      delay(5000);
      while (client.connect("yun_energy") != 1) {
        delay(4000);
      }
      digitalWrite(LED, HIGH);
      client.publish("watch", "Energy Monitor reconnected");
    }
    MQTT_reconnect = millis();
  }
}

Schema's