Robuste physische Schnittstelle für Smart Home Steuerung

Komponenten und Materialien

Komponente	Menge
TowerPro SG90 Servo	3
Kleine Scharniere	2
Taster	2
Arduino Yun (oder Uno + Ethernet Shield)	1
Stromwandler 100A (YHDC SCT-013-000)	1
Widerstände & Kondensatoren	7

Über das Projekt

Zwei Videos unten erklären das Projekt kurz.

Idee: Physische vs. Virtuelle Schnittstelle

Die meisten Smart-Home-Systeme nutzen virtuelle Interfaces: Handy-App öffnen, Status prüfen, Lichter schalten. Das funktioniert unterwegs, aber zu Hause ist es umständlich – man muss aufs Display schauen, Informationen parsen, fokussieren. Nicht intuitiv.

Ich wollte eine physische Schnittstelle – ein kleines Modellhaus, das die realen Zustände physisch nachbildet. Garagentor offen → Modell-Garagentor offen. Auf dem Couchtisch oder am Schreibtisch im Büro (per VPN verbunden): Ein Blick genügt, um zu sehen, ob Haustür oder Garagentor offen stehen. So kreativ oder utilitär wie man möchte.

Projektplan

1. Modellhaus bauen – Türpositionen, Energieverbrauch, Lichtstatus anzeigen
2. Energiemonitor bauen (OpenEnergyMonitor Bibliothek) → Daten an Modellhaus & OpenHAB
3. Tür/Fenster-Sensoren anbinden – DIY-Option & Wink Hub + "Tripper" Kontaktsensoren
4. Ausgänge steuern – Licht an/aus, echtes Garagentor öffnen/schließen via Wink & Arduino

Modellhaus: Servos & LEDs an Arduino-Controller. Dieser abonniert MQTT-Topics (Türpositionen, Energieverbrauch) und bewegt Servos entsprechend. LED zeigt Lichtstatus.

Sensor-Daten → MQTT-Broker (Mosquitto auf Raspberry Pi). OpenHAB auf Pi für Smartphone-App & Fernzugriff. Virtuelles Interface bleibt erhalten.

Zwei Taster am Modellhaus:

• Taster 1: ZigBee-Lampe ein/aus togglen
• Taster 2: Echtes Garagentor öffnen/schließen

Teil 1: Hausbau

Schritt 1: Modellhaus bauen

Nicht präskriptiv – nach eigenem Haus & Interessen gestalten. Ich bin Bastel-Anfänger, zeige nur meine Umsetzung.

Bauteile

• Karton/Schachtel (Größe & Proportionen frei)
• 3× TowerPro SG90 Servo
• 2× kleine Scharniere
• Klebe-Material (3M doppelseitig)
• Arduino Yun (WLAN) oder Uno + Ethernet Shield
• 2× Taster
• Haushaltsmaterialien

Dach

Seitenklappe abschneiden, an andere Klappe kleben → Dach. Kleine Box als Winkelhilfe, später Lego-Stein zur Stabilisierung.

Türen / Fenster

Ausschnitte für zu überwachende Türen. Scharniere mit doppelseitigem Klebeband an Tür & Haus. Garagentor: Servo-Arm öffnet, Schwerkraft schließt. Haustür: Schnur an Tür, Servo-Arm zieht auf. Gelber Lego-Stein als Abstandhalter Servo-Scharnier.

Energiemesser

Pfeil an Servo-Arm, "Strauch" mit kW-Skala, Servo mit Strauch in Box reibschlüssig montieren. Rote LED über Energiemesser (Licht-an-Anzeige).

Taster

2 Momentantaster, mit Mutter an Kartonwand fixiert, Lötkontakte innen.

Schritt 2: Verkabelung & Code

Pin-Belegung

• Status-LED (MQTT): D7
• Licht-Anzeige-LED: D4
• Servo 1 (Haustür): D3
• Servo 2 (Garagentor): D5
• Servo 3 (Energiemesser): D6
• Taster 1 (Licht): D8
• Taster 2 (Garagentor): D9

Controller-Optionen

• Arduino Uno + Ethernet Shield (~20$) – kabelgebunden
• Arduino Yun (~65$) – WLAN, flexibler. Einfach: Per LAN an Router, Webinterface aufrufen, Passwort/Statische IP setzen, Sketch hochladen.

Sketch für beide Versionen unten. Yun-Code basis für Uno-Code (außer Ethernet-Bridge). Taster erst nach Yun-Umstieg hinzugefügt (Uno-Sketch hat keine Taster).

Videos: Yun Demo | Uno Demo

Dateien: smarthome_ethernet.ino | smarthome_yun.ino

Teil 2: Eingänge (Sensoren)

Schritt 3: Sensor – Energiemonitor

Sensor-Node für Hausstromverbrauch → MQTT. Arduino Yun (einfachste Methode). Alternativ: Uno + Ethernet + WLAN-Bridge oder Raspberry Pi mit OpenEnergyMonitor.

Stromwandler: 7$ YHDC SCT-013-000 (100A) von eBay. Schaltung laut Diagramm, Yun-Sketch hochladen (MQTT-Broker IP anpassen). Referenz: OpenEnergyMonitor.

Ideale Bauteilewerte

• Lastwiderstand (Burden): 33Ω
• Spannungsteiler-Widerstände: 10kΩ
• Kondensator: 10µF

Meine Umsetzung: 2×68Ω parallel (≈34Ω), 2×22µF in Reihe (≈11µF) – nah genug dran.

Stromwandler an eine eingehende Phase klemmen (nur 1 Phase überwacht). Abweichung: ~1A über Referenzmessgerät → im Code einfach 1A abziehen.

OpenHAB Integration

Daten auch in OpenHAB für Graphen.

Items:

Number itm_smarthome_energy_amps "Energy (amps) [%.1f]" {mqtt="<[mymosquitto:2853:state:default]"}
Number itm_smarthome_energy_watts "Energy (Watts) [%.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
    Chart item=itm_smarthome_energy_watts period=h refresh=5000
  }
}

Persistence (RRD4J):

Strategies {
  everyMinute: "0 * * * * ?"
}
Items {
  itm_smarthome_energy_watts: strategy = everyUpdate
  // ... weitere Items
}

Datei: energy_monitor_yun.ino

Schritt 4: Sensor – DIY Funk-Sensor-Nodes

Optionen für kabellose Öffnungs-Sensoren:

• Vorheriges Projekt: 5$ Funk-Modul (nRF24L01+) → MQTT-Gateway. Läuft noch für Garagentor-Status (Demo-Video). Code/Schaltung in verlinktem Instructable.
• Lichtsensor (Fotowiderstand) aus gleichem Projekt → "Licht an/aus" Status per MQTT.
• Batteriebetriebener Reed-Sensor (selbe Hardware) – aber hässlich, nicht für Wohnräume tauglich.

→ Bessere Optik: Consumer-Sensoren von Wink (nächster Schritt).

Schritt 5: Sensor – Wink Hub

Blog-Post fand Root-Exploit für frühen Wink Hub → PHP "aprontest" Utility → lokale Steuerung gepaarter Geräte ohne Wink-Server.

Vorteil: Lokale Kontrolle über Lights & Sensor-Status im LAN (kein Internet nötig). Normalerweise geht alles über Wink-Cloud.

PHP-Skript auf Pi: Pollt Wink Hub nach 2x Wink Tripper (Reed-Sensor) Status → sendet an OpenHAB REST API → OpenHAB publiziert MQTT-Topics → Modellhaus abonniert → Türen bewegen sich.

OpenHAB Config (Items, Sitemap, Rules) im Anhang. Auch Beispiel für ZigBee-Lampe via OpenHAB.

Video: Wink Integration

Dateien: sitemap.txt | rules.txt | items.txt | demo_1_general.sh | polling.php

Schritt 6: Ausgang – Lichtsteuerung

Vorherige Schritte lieferten alles für "Connected Bulb" Steuerung via physisches Interface & OpenHAB. Getestet: Cree Connected Bulb & GE Wink Lights. Video: Lichtsensor & Taster Demo

Schritt 7: Ausgang – Garagentor-Öffner

Config aus Schritt 5 deckt OpenHAB-Seite. Hardware für Torsteuerung (aus früherem Projekt):

• Arduino Clone (~10$)
• Ethernet Shield (~7$)
• Reed-Relais (~2$)
• Ersatz-Garagentor-Fernbedienung (~22$)

Arduino schaltet Reed-Relais → schließt Kontakte der Fernbedienung kurz. Pin 5 & GND → Relais-Spule (äußere Pins), innere Relais-Kontakte → Fernbedienungs-Taster.

Arduino abonniert MQTT-Topic → bei Open/Close Befehl → Relais kurz energisieren. Sketch: grage_opener.ino. Zusatz-Regel: garage_monitor_rules.txt (Audio-Ankündigung beim Öffnen – im 1. Video bei ~1:30 hörbar).

Videos: Torsteuerung | Audio-Regel

Dateien: garage_monitor_rules.txt | grage_opener.ino

Schritt 8: Weitere Gedanken

Entscheidungen spiegeln meine Tools, Teile & Prioritäten wider. Sie haben andere Voraussetzungen & Ideen.

Flexibilität durch MQTT & OpenHAB:

• Modellhaus-Controller: Arduino, Raspberry Pi, Spark Core, ESP8266...
• DIY-Sensoren: Arduino, ESP8266 standalone...
• Einzige Bedingung: Sensordaten → MQTT-Broker
• USB Z-Wave Stick an OpenHAB → Z-Wave zu MQTT Bridge → Z-Wave Türsensoren nutzen
• Wink Sensoren ohne Root: Wink API → OpenHAB/MQTT (braucht Internet, aber kein Root)

Viele Wege führen zum Ziel. Ich nutze gern "Lowest Common Denominator" Hardware: Arduino & Kartons.

Code

smarthome_yun.ino

// Eric Tsai 2015-04-13
// Arduino Yun Code für physisches Smart Home Interface
// MQTT Topics & Broker IP anpassen!

#include 
#include 
#include 
#include 

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

bool conn_ok;
int ledPin = 4;      // Licht-Anzeige
int statusPin = 7;   // MQTT Status

// Servos
int servo1Pin = 3;   // Haustür
int servo2Pin = 5;   // Garagentor
int servo3Pin = 6;   // Energiemesser
Servo servo1, servo2, servo3;

int button1 = 8;     // Taster Licht
int button2 = 9;     // Taster Garagentor

// Servo Zielpositionen
int servo1_target = 5, servo2_target = 5, servo3_target = 180;
int servo1_pos_cur = 5, servo2_pos_cur = 5, servo3_pos_cur = 180;
int servo1Opened = 5, servo1Closed = 130;
int servo2Opened = 5, servo2Closed = 150;

unsigned long servo1_time = 0, servo2_time = 0, servo3_time = 0;
unsigned long button1_db = 0, button2_db = 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);

  // LED (Topic 2822)
  if (mytopic == 2822) {
    digitalWrite(ledPin, mymsg == 1 ? HIGH : LOW);
  }
  // Servo 1 Haustür (2832)
  if (mytopic == 2832) {
    servo1_target = (mymsg == 1) ? servo1Opened : servo1Closed;
  }
  // Servo 2 Garagentor (2842)
  if (mytopic == 2842) {
    servo2_target = (mymsg == 1) ? servo2Opened : servo2Closed;
  }
  // Servo 3 Energie (2852) – Wert in Watt
  if (mytopic == 2852) {
    mymsg = constrain(mymsg, 0, 6000);
    servo3_target = 180 - ((1 - ((6000 - mymsg) / 6000.0)) * 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!");
  
  client.subscribe("2822"); // LED
  client.subscribe("2832"); // Haustür
  client.subscribe("2842"); // Garagentor
  client.subscribe("2852"); // Energie
  
  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();
  
  // Servos langsam zur Zielposition bewegen (non-blocking)
  if (millis() - servo1_time > 20) {
    servo1_pos_cur += (servo1_pos_cur < servo1_target) ? 1 : -1;
    servo1.write(servo1_pos_cur);
    servo1_time = millis();
  }
  if (millis() - servo2_time > 20) {
    servo2_pos_cur += (servo2_pos_cur < servo2_target) ? 1 : -1;
    servo2.write(servo2_pos_cur);
    servo2_time = millis();
  }
  if (millis() - servo3_time > 20) {
    servo3_pos_cur += (servo3_pos_cur < servo3_target) ? 1 : -1;
    servo3.write(servo3_pos_cur);
    servo3_time = millis();
  }
  
  // Taster 1 (Licht) – Debounce 3s
  if (digitalRead(button1) == LOW) {
    if (millis() - button1_db > 3000 || button1_db > millis()) {
      button1_db = millis();
      client.publish("2862", "button1 yaya");
    }
  }
  // Taster 2 (Garagentor) – Debounce 3s
  if (digitalRead(button2) == LOW) {
    if (millis() - button2_db > 3000 || button2_db > millis()) {
      button2_db = millis();
      client.publish("2872", "button2 yaya");
    }
  }
  
  // MQTT Reconnect alle 60s
  if (millis() - MQTT_reconnect > 60000) {
    conn_ok = client.connected();
    digitalWrite(statusPin, conn_ok ? HIGH : LOW);
    if (!conn_ok) {
      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 + Ethernet Version
#include 
#include 
#include 
#include 

byte mac[] = { 0x90, 0xA2, 0xDA, 0x0D, 0x43, 0x13 };
byte server[] = { 192, 168, 1, 101 };
EthernetClient ethClient;
PubSubClient client(server, 1883, callback, ethClient);

// ... (ähnliche Logik wie Yun-Version, aber mit Ethernet.begin DHCP)
// Vollständiger Code im Original

energy_monitor_yun.ino

/* Eric Tsai 2015-04-22
   Arduino Yun – Energieverbrauch an MQTT publizieren
   Broker IP in PubSubClient anpassen!
*/
#include 
#include 
#include 
#include "EmonLib.h"

int LED = 3;
EnergyMonitor emon1;
unsigned long MQTT_reconnect = 0, 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); // Pin A5, Kalibrierung 60
}

void loop() {
  char buff[12];
  client.loop();
  Irms = emon1.calcIrms(1480);
  
  if (millis() - read_energy > 10000) {
    // Ampere
    dtostrf(Irms, 4, 5, buff);
    client.publish("2853", buff);
    // Watt (bei 115V)
    dtostrf(Irms * 115, 4, 5, buff);
    client.publish("2852", buff);
    read_energy = millis();
  }
  
  // MQTT Reconnect
  if (millis() - MQTT_reconnect > 60000) {
    conn_ok = client.connected();
    digitalWrite(LED, conn_ok ? HIGH : LOW);
    if (!conn_ok) {
      client.disconnect(); delay(5000);
      while (client.connect("yun_energy") != 1) delay(4000);
      digitalWrite(LED, HIGH);
      client.publish("watch", "Energy Monitor reconnected");
    }
    MQTT_reconnect = millis();
  }
}

Schaltpläne