ESP8266 & NodeMCU (LUA) Tutorial – Temperatursensor DS18B20 abfragen

Dies ist Teil zwei meiner Tutorialserie zum ESP8266.
Teil eins ist hier zu finden: „ESP8266 & NodeMCU (LUA) Einstiegstutorial

Inhalt

  1. Einleitung
  2. Voraussetzungen
  3. Hardware-Vorbereitung
  4. Firmware flashen
  5. Das Programm

Einleitung

Im ersten Teil der Reihe habe ich beschrieben, was der ESP8266 ist, wie man die Firmware auf den Controller läd und sich in der Programmierumgebung ESPlorer mit dem Chip verbindet und die Verbindung überprüft.

Hier soll es nun darum gehen, ein einfaches Programm zu erstellen, um mehrere Temperatursensoren DS18B20 einzubinden und Daten wie Chip-Adresse und die Temperatur anzuzeigen.

Voraussetzungen

Als Hardware wird der ESP8266 in Form des ESP-01 genutzt, grundsätzlich funktioniert natürlich jedes andere Modul mit mindestens einem GPIO-Pin. Dieses Tutorial ist aber ausdrücklich für den ESP-01 geschrieben und auch nur auf diesem getestet.

Ansonsten gehe ich davon aus, dass sowohl das ESPTool zum flashen der Firmware, als auch der ESPlorer bereits installiert sind und funktionieren.

Praktisch wäre es natürlich auch, wenn zwei Temperatursensoren DS18B20 vorhanden sind, diese sind auf ebay sehr günstig aus China, oder etwas teurer aus Deutschland erhältlich. Außerdem wird ein 4,7 Kiloohm-Widerstand benötigt.

Hardware-Vorbereitung

Zuerst sollten wir die Hardware entsprechend zusammen stecken. Grundsätzlich ist der Aufbau sehr ähnlich der bereits aus dem ersten Teil bekannten Konfiguration, hinzu kommen nur ein 4k7Ω Widerstand, sowie die beiden DS18B20. Die Grafik sieht der Übersicht halber ein wenig anders aus, ist aber tatsächlich nur in den genannten Details unterschiedlich zur Grafik aus dem ersten Teil.

Der ESP8266 auf einem Breadboard mit dem zwei Temperatursensoren DS18B20
ESP8266 mit DS18B20

Auf dem Breadboard sieht das in etwas komprimierter Form bei mir so aus:

Der ESP8266 mit zwei DS18B20 zusammengesteckt auf einem Breadboard
ESP8266 mit DS18B20 auf Breadboard

Wie man sieht, habe ich die Sensoren direkt auf das Breadboard gesteckt, ebenso den Widerstand.

Firmware flashen

Hier soll es nicht darum gehen, wie die Firmware auf den Chip kommt, sondern darum, dass die korrekte Firmware auf den Chip kommt. Im weiteren Verlauf des Tutorials wird eine Bibliothek genutzt, die verschiedene Module in der Firmware des ESP8266 benötigt.

Die von mir genutzte Firmware enthält die Module

  • file
  • gpio
  • net
  • node
  • ow
  • tmr
  • uart
  • wifi

geflasht ist die float-Version, da dies für die genutzte Bibliothek des DS18B20 notwendig ist.

Wer mag, kann auch die von mir genutzte Firmware hier herunterladen, dann ist alles genau gleich.

Wie die Firmware auf den ESP8266 kommt, habe ich ja bereits geschrieben, dies sollte nun geschehen.

Das Programm

Nun sollte alles bereit sein: Die Hardware ist zusammengesteckt, die Firmware ist auf den ESP8266 geflasht und die Programmieroberfläche ESPlorer ist installiert und einsatzbereit.

Um die Sensoren über unser einfaches Programm abfragen zu können, benötigen wir die Bibliothek ds18b20.lua, die ich vor längerer Zeit mal im Git-Repo von NodeMCU heruntergeladen habe. Ich weiß leider nicht mehr genau, welche der Bibliotheken es war, daher stelle ich auch diese hier zum Download zur Verfügung. Die Bibliothek kann an beliebiger Stelle entpackt werden und dann im ESPlorer geöffnet werden. Hierzu einfach im Reiter „NodeMCU & MicroPython“ auf „Open“ klicken, zu der Datei navigieren, auswählen und öffnen:

Bibliothek ds18b20.lua in ESPlorer öffnen
Bibliothek ds18b20.lua in ESPlorer öffnen

Die geöffnete Datei muss nicht weiter angepasst werden, sie wird nun per Klick auf „Save to ESP“ in den Speicher des ESP8266 geladen und ist ab diesem Zeitpunkt auf dem Gerät nutzbar.

Nun schreiben wir das eigentliche Programm, welches die eben gespeicherte Bibliothek nutzt, um Daten von angeschlossenen DS18B20-Sensoren zu empfangen und auszugeben. Der Dateiname ist hier ds18b20-test.lua.

-- Testprogramm um mehrere DS18B20 zu lesen

-- GPIO-Pin festlegen
pin = 3

-- DS18B20-Modul und GPIO initialisieren
t=require("ds18b20")
t.setup(pin)
addrs=t.addrs()

-- Anzahl der DS18B20 ausgeben
print('Anzahl Sensoren: ' .. table.getn(addrs))

-- Adresse(n) der DS18B20 ausgeben
for k, v in pairs(addrs) do print('Adresse Sensor ' .. k .. ':', v:byte(1,8)) end

for k, v in pairs(addrs) do
print('Temperatur Sensor ' .. k .. ': ' .. t.read(v,C) .. ' Grad Celsius')
end

-- Alle Ressourcen wieder freigeben
t = nil
ds18b20 = nil
package.loaded["ds18b20"]=nil

Die Kommentare sagen eigentlich schon so ziemlich alles: Der nutzbare GPIO-Pin heißt in der Firmware Pin 3 und wird am Anfang des Programms festgelegt. Die eben auf das Gerät geladene Bibliothek wird geladen und der Pin übergeben. Nun wird gezählt, wieviele Sensoren gefunden wurden, die Zahl wird ausgegeben, danach die Adressen der Sensoren, sowie der Temperaturwert.
Zum Schluss werdend die Ressourcen wieder freigegeben.

Auch dieses Programm kann hier heruntergeladen werden, da vermutlich Hochkommata etc. hier falsch dargestellt sein dürften.

Diese Datei muss nun wie schon die Bibliothek per Klick auf „Save to ESP“ in den Speicher des ESP8266 geladen werden. Ist dies geschehen, wird das Programm bereits ausgeführt. Es sollte also in etwa so aussehen:

Das Programm wird im ESPlorer in den Speicher geladen und danach automatisch ausgeführt.
Das Programm wird gespeichert und ausgeführt

Wir sehen also, dass die beiden Sensoren funktionieren und uns neben ihrer Adresse auch die Temperatur melden.

Um das Programm nun über den ESPlorer ausführen zu lassen, müssen wir nur den Befehl

dofile("ds18b20-test.lua");

in der Befehlszeile unten im ESPlorer ausführen und bekommen schon unser gewünschtes Ergebnis zurück:

Das Programm wird im ESPlorer mit dem Befehl dofile("ds18b20-test.lua"); ausgeführt.
DS18B20 abfragen über ESPlorer

Damit geht dieses Tutorial auch wieder zuende, im (hoffentlich bald folgenden) nächsten Teil steigen wir dann etwas tiefer ein und lassen das Programm zyklisch auf dem Controller laufen und die Werte über eine einfache Webseite im LAN/WLAN ausgeben.

ESP8266 & NodeMCU (LUA) Einstiegstutorial

Vor ein paar Wochen stolperte ich über einen Chip mit dem klangvollen Namen ESP8266. Julian Ilett stellte ihn in einem Video vor und kurz darauf machten sich zwei Module aus China auf den Weg zu mir.
Da der ESP8266 ein für Bastler ziemlich interessanter Chip ist, habe ich mich entschlossen, ihm ein paar Artikel zu widmen, dies ist der erste.

Inhalt

  1. Der ESP8266
  2. Das Tutorial
  3. Die Hardware
  4. Zusammenstecken
  5. NodeMCU Firmware flashen
  6. Die Programmierumgebung

Der ESP8266

Vom ESP8266 wird häufig als WLAN-Modul gesprochen und tatsächlich sieht man im Netz viele Projekte, die ihn als reine Seriell-zu-WLAN-Schnittstelle für beispielsweise einen Arduino nutzen.
Der ESP8266 ist allerdings deutlich mehr, denn neben der WLAN-Funktionalität ist er ein kompletter Microcontroller, der mit verschiedenen Firmwares geflasht und dann beispielsweise in C, C++ oder LUA programmiert werden kann.

Der Microcontroller hat soweit ich weiß 12 GPIO-Pins, die unter anderem I2C, SPI, UART, GPIO und PWM bereitstellen und einen 3,3V-Pegel führen. In Verbindung mit seiner WLAN-Schnittstelle eignet er sich damit ziemlich gut als Controller für die ganzen modischen IoT-Dinge, wie beispielsweise einen WLAN-Temperatursensor oder -Lichtschalter.

Der Microcontroller wird auf verschiedenen Breakout- und Devboards angeboten, die mal mehr, mal weniger Funktionen des Chips unterstützen.

Das Tutorial

In diesem Tutorial soll es darum gehen, den Chip über eine Serielle Schnittstelle (UART) mit dem Computer zu verbinden und zwei der wichtigsten Tools in Betrieb zu nehmen.

Ich benutze in diesem Tutorial ein Breakout-Board mit dem Namen ESP-01, welches neben der UART-Schnittstelle und den für den Betrieb wichtigen Pins nur einen nutzbaren GPIO-Pin nach außen führt. Dafür bekommt man es für einen niedrigen, einstelligen Euro-Betrag aus China oder auch aus Deutschland.

Frontansicht des ESP-01 Breakout-Boards
Der ESP8266 als ESP-01 Breakout-Board

Natürlich können auch andere Ausführungen genutzt werden, populär ist beispielsweise das Development-Kit von NodeMCU, welches schon eine eigene USB-zu-Seriell-Schnittstelle mitbringt und neben den 5V per USB keine weitere Spannungsversorgung benötigt. Außerdem hat dieses Dev-Board einen Reset-Knopf und einen Knopf für GPIO0, welcher zum Flashen neuer Firmware benötigt wird, doch dazu später mehr.

Der ESP8266 aufgelötet auf ein Development-Board von NodeMCU
ESP8266 auf dem NodeMCU-Devboard

Ich benutze in diesem Tutorial einen Linux-PC, manche verwendete Software gibt es für Windows eventuell nicht und bei der Installation ist die Vorgehensweise sicherlich eine andere.

Die Hardware

Neben dem schon angesprochenen ESP8266 benötigen wir entweder eine Serielle Schnittstelle und einen Pegelwandler wie einen MAX3232, um auf den vom ESP8266 benötigten LVTTL-Pegel von 3,3V zu kommen, oder einen USB-Adapter, der beispielsweise per FTDI-Chip direkt LVTTL-Pegel hat. Einen solchen USB-zu-TTL-Adapter gibt es auch auf ebay für wenig Geld.

Um die Teile unkompliziert zusammen stecken zu können, sollte man auf ein Breadboard, also ein Elektronik-Steckbrett und fertige Jumper-Kabel zurückgreifen. Beides gibt es sehr günstig in tausendfacher Ausführung bei ebay.

Außerdem benötigt das Modul selbst noch eine Spannungsversorgung. Viele USB-zu-TTL-Platinen bringen eine zwischen 5V und 3,3V einstellbare Versorgungsspannung mit, diese ist jedoch zu instabil und der benötigte Strom übersteigt meistens die Kapazität der Platine. Es sollte also eine externe 3,3V-Spannungsquelle genutzt werden. So etwas gibt es auch bei ebay fertig für die Verwendung mit Breadboards.

Zusammenstecken

Das Modul ESP-01 ist leider nicht Breadboard-freundlich, muss also entweder fliegend verdrahtet, oder per selbstgebautem Adapter auf das Breadboard gesteckt werden. Ich nehme hier die erste Lösung und verbinde das Modul fliegend mit Jumperwire.

Da die Module üblicherweise völlig undokumentiert verschickt werden und das ESP-01 oft auch kein gedrucktes Pinout hat, habe ich hier einen Belegungsplan gemacht.

Pinout des ESP8266 ESP-01 Moduls
Pinout des ESP-01 Moduls

Nun müssen die Pins des ESP8266 über das Breadboard mit dem FTDI-Modul und der Spannungsversorgung verbunden werden. Wichtig ist, dass die Spannungsversorgung auf 3,3V eingestellt ist, 5V würden das Modul zerstören. Das Schema sieht wie folgt aus:

Der ESP8266 angeschlossen an das Breadboard und verbunden mit einer FTDI-Schnittstelle
ESP8266 ESP-01 an FTDI

GND wird mit GND auf dem Breadboard verbunden, VCC mit +3,3V, ebenfalls an 3,3V wird der Pin CH_PD angeschlossen.

RXD und TXD werden gekreuzt mit RXD und TXD des FTDI-Adapters verbunden, GND der Schnittstelle muss auf jeden Fall auch zu GND auf dem Breadboard gebrückt werden. Wie weiter oben schon beschrieben, sollte man nicht versuchen, den ESP8266 über die Spannungsversorgung des FTDI-Adapters zu betreiben, VCC des Adapters bleibt also unbelegt.

RST am ESP8266 ist der Reset-Anschluss, der genutzt wird, um das Programm auf dem Chip neu zu starten. Dies kann später auch Softwareseitig geschehen, der Pin kann freigelassen werden.

GPIO0 ist ein Pin, der leider nicht für externe Anwendungen genutzt werden kann. Er wird auf GND verbunden, um in den Flash-Modus zu gelangen. Im Normalbetrieb ist er nicht belegt.

GPIO2 ist der tatsächlich nutzbare GPIO-Pin, der für externe Anwendungen wie OneWire, Digital I/O usw. genutzt werden kann. Dazu in weiteren Tutorials mehr.

NodeMCU Firmware flashen

Im Auslieferungszustand ist der ESP8266 vermutlich mit der AT-Firmware geflasht. Bei den billigen China-Modulen kommt es auch vor, dass überhaupt keine lauffähige Firmware vorhanden ist und das Modul darüber nicht ansprechbar ist.

Nun heißt dieses Tutorial aber „ESP8266 & NodeMCU (LUA) Einstiegstutorial“, also sollte auch die NodeMCU-Firmware auf den Chip kommen. Wir benötigen folgendes dazu:

  • Firmware
  • Flash-Tool

Die Firmware kann entweder aus dem Sourcecode gebaut werden, oder aber über eine bequeme Weboberfläche zusammen geklickt werden. Der Einfachheit halber entscheiden wir uns hier für letztere Option und lassen uns die Firmware von der Seite nodemcu-build.com bauen und per Mail zusenden. Die ausgewählten Module reichen eigentlich aus, um den Chip in Betrieb zu nehmen und auch eine LED blinken zu lassen.

Achtung: Vor dem Flashen muss der Pin GPIO0 mit GND verbunden werden, andernfalls kann die Firmware-Ebene nicht erreicht werden.

Das Flash-Tool ist ein Python-Programm, das über pypi installiert werden kann (Vorausgesetzt ist Python >= 2.7 und pip):

pip install esptool

Ist das Flash-Tool installiert und die Firmware vorhanden, starten wir den ESP8266 und verbinden die serielle Schnittstelle mit dem Computer. In der Konsole sollte dmesg nun als eine der letzten Zeilen etwas derartiges ausgeben:

FTDI USB Serial Device converter now attached to ttyUSB0

Wir wissen also, dass der PC den Adapter erkannt hat und dass er die Gerätedatei /dev/ttyUSB0 bekommen hat.

Nun müssen wir nur noch die Firmware flashen. Die Syntax dafür ist:

python esptool.py --port /dev/ttyUSB0 write_flash 0x00000 /pfad/zur/firmware.bin

Das sieht dann in natura so aus:

Konsole mit der Ausgabe des esptool beim Flashen des ESP8266
NodeMCU-Firmware auf den ESP8266 flashen mit esptool

Nun ist die neue Firmware auf dem ESP8266 und kann nach einem Neustart genutzt werden. Nicht vergessen, GPIO0 wieder von GND zu trennen, um in den Betriebsmodus zurückzukehren.

Die Programmierumgebung

Der ESP8266 kann nun über LUA programmiert werden. Um die Verbindung herzustellen und einige Helferlein an die Hand zu geben, gibt es eine Programmierumgebung namens ESPlorer. Die Software benötigt Java und läuft auf allen Betriebssystemen, die das unterstützen. Herunterladen kann man ESPlorer bei GitHub.

Programmieroberfläche ESPlorer, links der Code-Editor, rechts der serielle monitor
Programmieroberfläche ESPlorer

Oben kann nun die serielle Schnittstelle ausgewählt werden, über „Open“ verbindet sich die Oberfläche mit dem ESP8266. Dieser Antwortet mit so etwas wie:

NodeMCU custom build by frightanic.com
	branch: master
	commit: c8037568571edb5c568c2f8231e4f8ce0683b883
	SSL: false
	modules: file,gpio,net,node,ow,tmr,uart,wifi
 build 	built on: 2016-05-27 20:54
 powered by Lua 5.1.4 on SDK 1.4.0
lua: cannot open init.lua

Eventuell wird auch erst eine Fehlermeldung angezeigt. Startet man den ESP8266 neu, sollte er aber mit der Oberfläche kommunizieren. Meldet er sich nicht korrekt an, heißt das nicht, dass es nicht funktioniert hat, das kommt schon mal vor. Tippt man unten in das Textfeld neben dem grünen „Send“ Knopf

=node.chipid()

sollte der ESP mit der Chip-ID antworten. Tut er das, scheint es auch geklappt zu haben.

ESPlorer zeigt die Begrüßung der Firmware, aber auch Fehlermeldungen an
Der ESPlorer verbunden mit dem ESP8266

Damit ist dieses Tutorial schon beendet, der Chip wurde angeschlossen, geflasht und kann mit dem ESPlorer verbunden werden. ESPlorer unterstützt nun die Programmierung des Chips mit LUA-Scripts. Interessante Scripts und Bibliotheken findet man im GitHub der NodeMCU-Firmware.

Ich hoffe, ich konnte den Einstieg einigermaßen sinnvoll erklären, bei Fragen bitte einfach einen Kommentar hinterlassen.