Wie bereits in meinem vorangegangenen Artikel erwähnt, hatte ich mir einen Microcontrollerboard basierend auf dem ESP8266 von Espressif in der Bucht bestellt.
Die meisten kennen wohl nur den RaspberryPI und vielleicht noch den Arduino als Bastelplattform. Der nicht ganz so flüssig auszusprechende Espressif ESP8266 steht aber, zumindest der Arduino-Plattform in nichts nach. Nicht zuletzt deshalb, weil man ihn exakt so wie einen Arduino programmieren kann, sondern auch, weil der Funktionsumfang sehr ähnlich ist. Es gibt kleine Varianten, die nur über 2 freie GPIOs verfügen („ESP-01“, dafür aber wirklich günstig sind. In der Buch für unter 3EUR inkl. Versand erhältlich), sondern auch „große“ die zahlreiche analoge wie digitale Pins zur verfügung haben (z.B. „ESP-12“ und „ESP-13“).
Eine praktische Übersicht gibt es hier.
Der Hersteller hat für seinen Microcontroller ein eigenes SDK am Start. Infos bekommt man hier.
Doch die wenigsten DIY-Einsteiger wollen sich mit der Sprache C und deren Compiler beschäftigen. Die Lernkurve ist hier ein Argument das wohl häufig greifen wird.
Die Jungs und Mädels hinter dem Arduino haben das verstanden und die Sprache so weit wie möglich vereinfacht und ein reduziertes API für die eigentlichen AVR-Microcontroller gebastelt. Damit das funktioniert, steckt in den Arduinos ein spezielles Stück Firmware das als Bootloader dient.
Für den ESP8266 gibt es aber ebenfalls alternative Firmware. Wie weiter oben schon erwähnt kann man im Arduino-Stil den ESP8266 programmieren, und es gibt da noch NodeMCU. NodeMCU ist, ähnlich wie die Firmware für den Arduino, eine Abstraktion der Hardware. D.h. man muss sich nicht mit lästigen hardware-lastigen Code und Co. beschäftigen, sondern kann auf einfache Weise die Ein-Ausgabe-Pins direkt ansprechen, ohne viel „drum herum“ entwickeln zu müssen. Während das beim Arduino nach wie vor in C/C++ läuft, haben die Macher hinter NodeMCU die Scriptsprache „Lua“ gewählt.
Wer bisher Java oder C/C++ Code kennt, für den ist das im ersten Moment eine kleine Umstellung, aber ohne große Schwierigkeiten machbar. Auch der komplette Neueinsteiger findet sich dank einfacher Beispiele schnell zurecht. Ein Beispiel:
-- set pin index 1 to GPIO mode, and set the pin to high. pin=1 gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH)
Das aber wirklich tolle am ESP8266 ist das eingebaute WLAN, die geringen Abmessungen und der trotzdem geringe Preis (verglichen mit Arduino).
Der aber wirklich gravierende Unterschied zum klassischen Arduino ist: Der ESP8266 arbeitet mit 3.3V statt wie der Arduino mit 5V. Das betrifft nicht nur die Versorgungsspannung, sondern auch die I/O-Pins. Oben gezeigter Code legt also an PIN1 nicht 5V an, sondern 3.3V.
Daraus resultiert, dass man beim Anschluss von Sensoren und dergleichen auf den 3.3V Pegel achten muss.
So, genug Theorie. Jetzt zur Praxis: „Wie komme ich am einfachsten an einen funktionierenden Aufbau?“
Da kann ich aus meiner bisherigen (aber recht kurzen) Erfahrung das NodeMCU DevKit Modul empfehlen. Das ist im Prinzip ein ESP-12 Modul das um eine Trägerplatine mit dem notwendigen „Hühnerfutter“ und allen notwendigen Pins ausgestattet ist. Man bekommt es schon für knapp über 4EUR direkt aus China, oder für knapp unter 8EUR über ebay.
Der Vorteil des NodeMCU DevKits: Die NodeMCU Firmware ist schon drauf, alle wichtigen Pins sind sauber herausgeführt und es gibt einen fertigen USB-Anschluss zum anschließen an den PC.
In beiden Fällen muss man sich aber etwas Zeit lassen. Der Versand dauert eine ganze Weile…
Ist das gute Stück dann endlich angekommen kann es auch gleich losgehen. Wie beim Arduino gibt es hier auch eine IDE. Die ist zwar nicht vom Hersteller, aber ist dennoch ganz gut zu gebrauchen: Esplorer
Die IDE ist in Java geschrieben und läuft deshalb sowohl unter Windows wie unter Linux (letzteres war mir sehr wichtig).
Unter Windows muss man meist noch den CH340 Treiber für den RS232-Treiberchip installieren. Den bekommt man hier.
Devkit anstecken, IDE starten, COM-Port auswählen und verbinden. Und schon kanns losgehen.
Links im Fenster gibt man den Quellcode ein. Speichert man, wird die Datei automatisch in das Devkit übertragen und gleich ausgeführt. Die Ausgabe sieht man rechts im Fenster.
Und da fällt einem auch auf: „Es gibt Dateien auf dem Devkit?“ Jepp, gibt es. Der Speicher umfasst rund 4MB und man kann diesen mit Programmcode und/oder Konfigurationskram füllen. Auch zur Laufzeit. Man hat also ausreichend Platz um z.B. eine kleine Webseite zu hosten.
Hier passend dazu ein kleines Beispiel wie man mit dem ESP-01, also dem kleinsten, zwei Ein/Ausgänge über eine eingebaute Webseite ein/ausschaltet: ESP8266 Web Server Tutorial
Mein erster Einsatzzweck für das Devkit ist aber eine Luftgüte-Überwachung bzw. Aufzeichnung. Hierzu habe ich mir einen AMS iAQ Core VOC Sensor organisiert. Dieser gibt über eine i2c Schnittstelle den VOC-Wert, einen Status, den internen Messwiderstand sowie einen TVOC Wert aus. Da dieser Sensor mit 3.3V läuft, muss hier nichts adaptiert werden. Anschließen, Software basteln, fertig.
Mein erster Entwurf gibt die vier Messgrößen/Daten im JSON-Format über einen Socketserver aus:
-- reference id
id=0
-- D1
sda=1
-- D2
scl=2
iaqAddr = 0x5a;
iaqReg = 0xb5;
local measure = {}
-- initialize i2c
i2c.setup(id,sda,scl,i2c.SLOW);
-- read data register
-- i2c_addr: i2c address of i2c device to read
-- reg_addr: register address to read
-- lenght: number of bytes to read
local function read_reg(i2c_addr, reg_addr, length)
i2c.start(id)
i2c.address(id, i2c_addr, i2c.RECEIVER)
bytes = i2c.read(id, length)
i2c.stop(id)
return bytes
end
local function getByte(b, nr)
return string.byte(b,nr+1)
end
-- read iaq data
local function readIaq()
data = read_reg(iaqAddr, iaqReg, 9) -- read 9 bytes
-- print each byte to hex
--for i=0,8 do
-- print("byte["..i.."]="..string.format("%02x", string.byte(data, i+1)))
--end
-- prepare human-readable values
voc = bit.lshift(getByte(data,0), 8) + getByte(data, 1);
status = getByte(data,2);
resistance = bit.lshift(getByte(data,3), 24) + bit.lshift(getByte(data,4), 16) + bit.lshift(getByte(data,5), 8) + getByte(data,5);
tvoc = bit.lshift(getByte(data,7), 8) + getByte(data, 8);
-- prepare json structure
measure['voc'] = voc;
measure['status'] = status;
measure['resistance'] = resistance;
measure['tvoc'] = tvoc;
end
wifi.setmode(wifi.STATION)
wifi.sta.config("SSID", "PASSWORT")
wifi.sta.connect()
print("MAC: "..wifi.sta.getmac())
tmr.alarm(0, 1000, 1, function()
if wifi.sta.getip() == nil then
print("Connecting to AP...\n")
else
ip, nm, gw=wifi.sta.getip()
print("IP Info: \nIP Address: ",ip)
print("Netmask: ",nm)
print("Gateway Addr: ",gw,'\n')
tmr.stop(0)
end
end)
-- Start a simple socket server
srv=net.createServer(net.TCP)
srv:listen(44444,function(conn)
conn:on("receive",function(conn, c)
readIaq();
print("response: "..cjson.encode(measure));
conn:send(cjson.encode(measure))
end)
conn:on("sent",function(conn) conn:close() end)
end)
Die Verkabelung ist einfach: 3.3V und Gnd bekommt man vom Devkit. SDA hängt an Pin D1 und SCL an Pin D2.
Dann verbindet man sich z.B. mit Telnet auf Port 44444 des Devkits, sendet „irgend ein byte“ (z.B. die Enter-Taste) und bekommt als Antwort sowas:
{"status":0,"tvoc":206,"voc":744,"resistance":346441}
Wenn Status den Wert 17 (0x10) hat, dann ist der Sensor noch in der Start-Phase. Bei einem Status-Wert von 0 (0x00), kommen verlässliche Daten raus.
Die NodeMCU API bietet aber auch einen MQTT Client. Und genau das werde ich mir als nächstes anschauen.
Espressif hat im letzen SDK-Update noch Secure-Sockets, also quasi SSL, mit aufgenommen, so dass hier seitens NodeMCU sicher noch eine Verschlüsselungsfunktion mit Zertifikaten hinzu kommt. Man darf gespannt sein.
Ich überlege schon wie ich ein kleines Netzwerk an Sensoren und Aktoren in meine bestehende Hausautomation mit KNX integriere… MQTT wäre sicherlich ein Weg.
Ganz toll wäre es aber, wenn man die Geräte ohne Anpassung der Software (WLAN Zugangsdaten…) integrieren könnte. Am besten vielleicht mit einem „Lerntaster“. Mal schauen. Das API jedenfalls bietet „Smartconfig“ an, und NodeMCU scheint das auch zu unterstützen…
2 Trackbacks