Mein neuestes Projekt ist ein SmartHome-Gateway auf Basis des ESP8266, welches ich euch natürlich hier gerne vorstellen möchte. Momentan implementiert sind ein 433MHz-Sender für Funksteckdosen aller Art, eine IR-Diode sowie ein Temperatur-/Luftfeuchtigkeitssensor. Das Setup lässt sich natürlich beliebig erweitern und den eigenen Bedürfnissen anpassen.

Vorteile zu Lösungen mit Einplatinencomputer wie Raspberry / Banana Pi sind die Robustheit bei Stromausfällen (Stichwort(e) kaputtes Dateisystem) und natürlich auch der sehr günstige Preis.

 

1. Hardware

Als Board setze ich hier mein NodeMCU-Entwicklungsboard ein, da es praktischerweise über einen USB-Anschluss verfügt und Breadboard-tauglich ist. Außerdem bietet es im Gegensatz zu den kleineren ESP8266-Modellen wie dem ESP-01 wesentlich mehr GPIOs.
Meine (von einer alten Fernbedienung ausgelötete) IR-Sendediode steuere ich über einen Transistor (NPN mit CBE-Reihenfolge [momentan ein BC547]) an, die Basis habe ich mit einem Widerstand von ca. 600Ω mit einem digitalen Pin des Boards verbunden.

Als Temperatur-/Luftfeuchtigkeitssensor nutze ich einen DHT11. Dieser ist nicht sehr genau, aber für meine Bedürfnisse soweit ausreichend. Wer es genauer haben möchte, kann zu dem etwas teureren Modell DHT22 greifen, das sich analog einsetzen lässt.

Für die Funksteckdosen nutze ich schließlich noch einen billigen FS1000A-Transmitter mit externer Antenne. Diesen hatte ich von anderen Projekten noch über. Wer neukauft, sollte lieber einen Superheterodyne-Transmitter einsetzen, den es in China auch bereits für wenige Cent gibt. Dieser hat erfahrungsgemäß eine wesentlich höhere Reichweite und lässt sich ebenso einfach einstecken.

Eine kleine Steckplatinenansicht seht ihr hier:

Und so schaut es bei mir aktuell in der Realität aus:nodemcu_universal_1

2. Software

Dieses Projekt mit dem ESP8266 habe ich wieder mit Hilfe der Arduino IDE umgesetzt. Dort gibt es für die Ansteuerung der eingesetzten Sensoren und Aktoren bereits fertige Bibliotheken, sodass die Umsetzung damit sehr simpel ist.

Mein aktueller Sketch sieht insgesamt so aus:

smarthome_gateway.ino
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <RCSwitch.h>
#include <IRremoteESP8266.h>
#include <DHT.h>
 
// WLAN data
const char* ssid = "xxx";
const char* password = "xxx";
 
// static IP
IPAddress ip(192,168,11,60);
IPAddress gateway(192,168,11,1);
IPAddress subnet(255,255,255,0);
 
MDNSResponder mdns;
ESP8266WebServer server(80);
 
// set your pin for ir led here
IRsend irsend(14);
// initialize RCSwitch
RCSwitch mySwitch = RCSwitch();
// initialize DHT sensor
DHT dht(13,DHT11,15);
 
float humidity, temperature;
 
void handleRoot() {
server.send(200, "text/html", "Please specify command!</br>Form IR: /ir?code=xxx&bits=xx&protocol=x</br>Form RC: /rc?group=xxxx&switch=xxxx&action=x</br>Form DHT: /dht?type=x");
}
 
void handleIr(){
  String codestring=server.arg("code");
  String protocol=server.arg("protocol");
  String bitsstring=server.arg("bits");
 
  String webOutput = "Protocol: "+protocol+"; Code: "+codestring+"; Bits: "+bitsstring;
    
  if ((codestring != "")&&(bitsstring != "")){
    unsigned long code = codestring.toInt();
    int bits = bitsstring.toInt();
    
    if (protocol == "NEC"){
      irsend.sendNEC(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "Sony"){
      irsend.sendSony(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "Whynter"){
      irsend.sendWhynter(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "LG"){
      irsend.sendLG(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "RC5"){
      irsend.sendRC5(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "RC6"){
      irsend.sendRC6(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "DISH"){
      irsend.sendDISH(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "SharpRaw"){
      irsend.sendSharpRaw(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else if (protocol == "Samsung"){
      irsend.sendSAMSUNG(code, bits);
      server.send(200, "text/html", webOutput);
    }
    else {
      server.send(200, "text/html", "Protocol not implemented!");
    }
  }
  else {
    server.send(200, "text/html", "Missing code or bits!");
  }
}
 
void handleRc(){
  String groupstring=server.arg("group");
  String switchstring=server.arg("switch");
  String actionstring=server.arg("action");
 
  String webOutput = "Group: "+groupstring+"; Switch: "+switchstring+"; Action: "+actionstring;
 
  char groupchar[groupstring.length()+1];
  groupstring.toCharArray(groupchar, groupstring.length()+1);
  char switchchar[switchstring.length()+1];
  switchstring.toCharArray(switchchar, switchstring.length()+1);
    
  if(actionstring=="1"){
    mySwitch.switchOn(groupchar, switchchar);
    server.send(200, "text/html", webOutput);
  }
  else if(actionstring=="0"){
    mySwitch.switchOff(groupchar, switchchar);
    server.send(200, "text/html", webOutput);
  }
  else{
    server.send(200, "text/html", "Wrong action code!");
  }
  
}
 
void handleDHT(){
  getDHT();
  String typestring=server.arg("type");
 
  String temp_str = String((int)temperature);
  String hum_str = String((int)humidity);
 
  if(typestring=="temp"){
    server.send(200, "text/html", temp_str);
  }
  else if(typestring=="hum"){
    server.send(200, "text/html", hum_str);
  }
  else{
    String webOutput = temp_str+";"+hum_str;
    server.send(200, "text/html", webOutput);
  }
 
}
 
void handleNotFound(){
  server.send(404, "text/plain", "404");
}
 
 
void getDHT(){
  humidity = dht.readHumidity();
  temperature = dht.readTemperature(false);
  if (isnan(humidity) || isnan(temperature)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }
}
void setup(void){
  mySwitch.enableTransmit(12);
  irsend.begin();
  dht.begin();
  Serial.begin(9600);
  WiFi.begin(ssid, password);
  WiFi.config(ip, gateway, subnet);
  Serial.println("");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  
  if (mdns.begin("esp8266", WiFi.localIP())) {
    Serial.println("MDNS responder started");
  }
  
  server.on("/", handleRoot);
  server.on("/ir", handleIr);
  server.on("/rc", handleRc);
  server.on("/dht", handleDHT);
  server.onNotFound(handleNotFound);
  
  server.begin();
  Serial.println("HTTP server started");
}
void loop(void){
  server.handleClient();
}

Alles wird also über einfache HTTP-Requests angesteuert. Zwar wäre auch eine Umsetzung z.B. über MQTT denkbar, allerdings braucht man dann noch einen Broker (bzw. nutzt einen im Internet) und die App-Auswahl zur Steuerung ist stark eingeschränkt (ich nutze hier NetIO für die Steuerung über eine GUI auf Android/iOS sowie AIVC zur Sprachsteuerung).

Die verwendeten Bibliotheken sind konkret:

  • rc-switch für die Funksteckdosen (siehe dazu ausführlichen Artikel hier)
  • IRremote für die IR-Diode (mehr dazu siehe hier)
  • DHT-sensor-library zum Auslesen des DHT11 in einer älteren Version (mit der neueren hatte ich massive Verbindungsprobleme zum Sensor)

Das HTTP-Interface habe ich dabei wie folgt gestaltet:

  • Für die Funksteckdosen: [IP]/rc?group=xxxx&switch=xxxx&action=x (wobei „group“ und „switch“ den DIP-Einstellungen der Steckdosen entsprechen und bei „action“ eine „1“ an entspricht und eine „0“ aus)
  • Für IR-Geräte: [IP]/ir?code=xxx&bits=xx&protocol=x („code“ entspricht hier der mit der Bibliothek ausgelesenem Code in Dezimal, „bits“ der ausgelesenen Länge und „protocol“ dem Protokoll [z.B. NEC oder Sony])
  • Für DHT-Sensor: [IP]/dht?type=x (dieser Befehl kann auch ohne „type“ aufgerufen werden, dann erhält man „[Temperatur];[Luftfeuchtigkeit]“, ansonsten lassen sich Temperatur und Luftfeuchtigkeit auch einzeln über „temp“ bzw. „hum“ auslesen/anzeigen)

3. Nutzung und Erweiterung

Wie bereits erwähnt nutze ich NetIO bzw. AIVC zur Steuerung. Das klappt mit beiden Apps vollkommen problemlos. Hier noch 2 Screenshots von meinen Ansichten in der NetIO-App (lassen sich bequem über einen Editor am PC anlegen):netio_nodemcu

Der Code lässt sich im Übrigen beliebig erweitern, sodass auch andere Sensoren oder Aktoren eingebunden werden können. Eventuell ergänze ich mein Setup demnächst noch um ein Barometer oder ähnliche Spielereien.

Momentan ist das Projekt ausgelegt auf eine permanente Stromversorgung über den Micro-USB-Anschluss, solltet ihr das Projekt (oder Teile davon) batteriebetrieben verwenden wollen, solltet ihr euch noch Gedanken um die Schlafzustände es ESP8266 machen.

Wenn ihr euer Setup in unterschiedlichen Umgebungen einsetzen möchtet, ist ein Blick auf das Projekt „WiFiManager“ für den ESP8266 sinnvoll, der es auch erlaubt, die WLAN-Daten schnell über ein Webinterface zu konfigurieren.

Bei Fragen zu dem Projekt oder Anregungen könnt ihr wie immer gerne das Kommentarfeld unten verwenden.

Verwandte Artikel: