NodeMCU und ESP8266 – Einstieg in die Programmierung

Was ist ein NodeMCU-Entwicklungsboard? Eigentlich ist es das, was viele Bastler lange Zeit gesucht haben, nämlich ein kompaktes kleines und sehr schnelles Controllerboard mit WLAN-Funktionalität, relativ viel Speicherplatz und sehr günstigem Preis von wenigen Euros. Zudem verfügt es über eine USB-Schnittstelle und Bootloader, es kann sehr bequem in der weit verbreiteten Arduino IDE programmiert werden.  Das Board beruht auf dem schon öfters bei uns angesprochenen WLAN-Chip ESP8266. Für Leser, die das NodeMCU-Entwicklungsboard oder den ESP8266 Chip noch nicht näher kennen, möchte ich  aufzeigen wie einfach man kleine WLAN-Projekte damit umsetzen kann.

Zunächst einmal ein paar Worte zu den beliebten ESP8266

Von den ESP8266 – Chips oder vielleicht auch dem ESP32 haben sicherlich schon die meisten etwas gehört. Es handelt sich hier um ein WLAN-Modul das in zahlreichen verschiedenen Varianten und Bauformen angeboten wird. Besonders preiswert bekommt man das Modul oft über Ebay oder Amazon oder direkt aus China.
Wir haben ja auch schon Projekte vorgestellt die ein ESP8266 verwenden, siehe unter Notruftaster oder Pretzel-Board. Die Module der ESP-Serie können sehr einfach über einen Mikrocontroller angesteuert werden, eine integrierte Firmware interpretiert AT-Befehle, ähnlich wie man es früher von den Modems her kannte.

Beliebte Bauformen/Varianten, alle mit einem ESP8266 Chip

Etwas weniger bekannt ist schon, dass die Module auch selbst sehr leicht programmiert werden können. Man braucht also eigentlich gar keinen zusätzlichen Mikroprozessor oder ein Arduino-Board. Viele haben sich noch nicht näher damit beschäftigt weil vielleicht erwartet wird, dass der Speicher sehr knapp sei oder die Sache sehr kompliziert ist. Sollte dieses Vorurteil bestehen, dann kann ich Euch aus Erfahrung sagen dass sich die Einarbeitung lohnt, denn zum einen ist der ESP8266-Chip mit 80 Mhz (maximal sogar 160 Mhz) ein vielfaches schneller als die meisten Arduino™-Boards und zum anderen bieten viele ESP8266-Module auch viel mehr Speicherresourcen.  Die etwas größeren ESP8266-Module (z.B. ESP-12E), die oft auch unter 5 Euro kosten, haben auch zahlreiche I/O-Ports und diverse serielle Schnittstellen wie SPI, i2C oder die beliebte  asynchrone serielle Schnittstelle. Zudem können alle GPIO-Ports auch genutzt werden um ein PWM-Signal auszugeben.
Reichen also einmal die I/O-Ports trotzdem nicht aus, so kann man die Module leicht über eine der Schnittstellen mit externen Bauteilen erweitern.
Die verschiedenen erhältlichen ESP8266 -Module unterscheiden sich eigentlich nicht in der Programmierung, kann man ein Modul programmieren, kann man im Grunde alle programmieren. Die wesentlichen Unterschiede sind die Anzahl und die Art der bereitgestellten Ports (GPIOs)  als auch der verfügbare Speicherplatz. Das kleine ESP-01-Modul hat beispielsweise 512 kB Flash-Speicher und das beliebte ESP-12E bereits 4 MByte Flash-Speicher.

Die Programmierung ist im Grunde ebenfalls sehr einfach, da sich um diese Module eine große Community gebildet hat und so sehr viele geeignete Tools und Libraries  erstellt oder angepasst wurden. Einige Tutorials wirken nur deshalb etwas kompliziert, weil dort gleichzeitig auf Windows und Linux  eingegangen wird. Oft wird dann auch noch gleichzeitig die Programmierung der Module per Arduino IDE, per Lua-Script oder per Phyton erklärt. Bei so viel Mischmasch ist es für Einsteiger oft schwer nicht nur “Bahnhof” zu verstehen.

Aus diesem Grunde beschränke ich mich in diesem kleinen Einstiegs-Tutorial ausschließlich auf die Leser, die einen ESP8266-WLAN-Chip bzw. das Board NodeMCU unter Windows programmieren möchten. Zudem verwenden wir zur Programmierung ausschließlich C, also die Arduino™ IDE. So kann ich Euch auch auf einige nervige Fallstricke aufmerksam machen, die man oft vergebens im Internet oder der Fachliteratur sucht.
Möglich ist es zwar auch die NodeMCU per Lua-Script oder sogar Phyton zu programmieren, aber dazu muss erst eine Firmware mit einem Interpreter in die Module geladen werden. Das kostet sehr viel Speicherplatz, der Platz für eigene Anwendungen wird dadurch erheblich reduziert. Zudem empfand ich die Lua-Programmierung auch nicht als sonderlich bequem. Wer sich dennoch mit Lua beschäftigen möchte, findet in diesem Beitrag Links auf andere gute Tutorials, die dazu aussagekräftiger sind.

Was genau ist das NodeMCU-Board?

Ein typisches NodeMSU Board

Nachdem Ihr nun wisst, dass der Microcontroller der Esp8266 – Module sehr leistungsfähig und programmierbar ist, kommen wir zum NodeMCU-Board. Im Grunde  ist ein NodeMCU-Entwicklungsboard nichts anderes als ein ESP8266 der um eine Usb-Schnittstelle (Uart/USB-Wandler auf dem Board) und eine Spannungsstabilisierung (ESP-Module arbeiten mit 3,3V) erweitert wurde. Zudem wurde die Pinbelegung des NodeMCU vereinheitlicht und ähnlich wie bei den Arduinos neu durchnummeriert. Weiterhin wurde die Programmierung erheblich vereinfacht, da jetzt auch die zwei Handshake-Leitungen per USB genutzt werden um das Board jederzeit per Arduino programmieren zu können. Es muss also nicht mehr wie bei den einzelnen Modulen darauf geachtet werden dass bestimmte Ports vor der Programmierung einen bestimmten Pegel erhalten. Zwar verfügt das NodeMCU-Board zusätzlich noch über zwei Taster (Reset und Flash), so dass man auch manuell die Programmierung einleiten kann, aber wenn man nur per Arduino IDE programmiert, braucht man diese Taster ebenfalls nicht nutzen. Möglich wird das durch zwei Transistoren auf dem NodeMCU-Board, sie sorgen dafür, dass bei der Programmierung per USB automatisch die richtigen Signale (auf GPIO0 und RESET) angelegt werden damit das Modul in den Programmiermodus geht. Man kann sich das gut im Schaltplan zum NodeMCU-Board anschauen, hier ein Auszug:

Schaltplan des USB-Teils auf dem NodeMCU-Board

Ein NodeMCU von unten gesehen. Die dortigen Angaben sind vorwiegend für LUA-Programmierer gültig

Es gibt mehrere Hersteller die ein NodeMCU-Board anbieten,  es gibt auch bereits mehrere Versionen. Unterschiede gibt es manchmal in der Größe, die Pinbelegung ist bei allen Modulen weitgehend gleich.  Bei manchen Modulen werden auf der linken Seite ein paar Ports mehr oder weniger bereitgestellt.
Alle NodeMCU-Boards beruhen auf dem ESP8266 Chip. Bis NodeMCU Version  0,9 noch auf der ESP-12-Variante, die nachfolgenden Versionen dagegen auf dem verbesserten ESP12E-Modul.

Beliebte ESP12-E Variante eines ESP8266 Moduls

Eine weitere Eigenheit eines NodeMCU-Boards ist, dass dieses gewöhnlich bereits mit einem LUA-Interpreter ausgeliefert wird. Die Entwicklerseite des NodeMCU-Boards unterstützt ebenfalls vorwiegend die Programmierung per Lua-Script, da man wohl der Meinung war, dass Einsteiger so am schnellsten zu Erfolgen kommen.

Aber das braucht uns nicht weiter stören, denn man kann die Software einfach per Arduino IDE mit einem beliebigen Arduino Sketch überschreiben. Das Board eignet sich genauso gut für C-Programmierer. Im Grunde braucht man nur das USB-Kabel einstecken und kann loslegen, es muss nichts mehr speziell für die Programmierung verkabelt werden, was die Sache sehr komfortabel für faule Programmierer macht 😉
Auch wenn man vorhat, später das fertige Programm aus Platzgründen oder aus Gründen des Strombedarfs direkt in ein ESP12E Modul einzuspielen, macht ein NodeMCU-Board bei der Entwicklung durchaus Sinn. Man kann so bequemer alles austesten und hat nicht so ein Kabelgewirr auf dem Tisch. Zudem kann man die meisten NodeMCU-Boards (z.B. die Variante 2.0 von Seeed) auch gut auf ein Steckbrett stecken und mit Sensoren etc. verkabeln. Es gibt inzwischen sogar einige Shields (Module zum Anstecken) wie Motortreiber etc., welche man direkt an das NodeMCU-Board anstecken kann. Ein kleiner, per Smartphone oder Browser gesteuerter Roboter ist also durchaus kein Problem für so ein Board. Aber auch Alarmanlagen oder komplexe Wetterstation und vieles mehr könnten einfach damit realisiert werden.
Dennoch werden Funk-Chips, wie z.B. das beliebte RFM12b-Modul  nicht vollständig durch so ein NodeMCU bzw- ESP-Modul verdrängt werden, denn ein Nachteil ist der hohe Strombedarf den WLAN generell benötigt. Das kann maximal schon mal bis zu 170 mA gehen. Das ist für Batteriebetrieb eigentlich viel zu hoch, zum Glück kann sich der ESP-Chip auch schlafen legen und automatisch wieder selbst wecken, dazu später mehr. Im sogenannte DeepSleep-Mode benötigt ein ESP-8266 nur noch 0,5µA.

Herz eines NodeMCU-Boards – das  ESP-12-E  Modul

Basis eines NodeMCU-Boards ESP8266-Modul Variante  ESP12-E

Pinbelegung eines NodeMCU-Boards (hier Version 2)

Ein komplettes NodeMCU-Board , oben ist das verwendete ESP12E-Modul mit Antenne zu erkennen

Bei der Pinbelegung in den oberen Zeichnungen ist zu beachten, dass nicht alle Signale und Ports zur freien Verfügung stehen. Einige Ports sind auf dem NodeMCU-Board oder auch ESP-12E-Modul selbst in Verwendung.

Hier eine Liste der intern verwendeten Signale

D0     GPIO16   Rote Led liegt mit Kathode an (kann dennoch verwendet werden)
MISO   GPIO7    Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet
MOSI   GPIO8    Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet
D11    GPIO9    Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet
D12    GPIO10   Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet
       GPIO11   Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet
       GPIO06   Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet
RXD0   GPIO3    Wird für USB-Schnittstelle benötigt
TXD0   GPIO1    Wird für USB-Schnittstelle benötigt
D4     GPIO2    Blaue LED des ESP12E Moduls
D3     GPIO0    Geht an Taster FLASH, kann jedoch ansonsten genutzt werden

Zur Info die untere Schaltungsskizze zeigt noch mal die interne Verschalung der Tasten auf dem NodeMCU-Board. Die hier angegebene blaue LED war bei den vorliegenden Modulen allerdings rot und nicht blau.

Der praktische Einstieg mit dem NodeMCU-Board

Man könnte noch viel zu den ESP8266-Modulen und auch zum NodeMCU-Board schreiben, aber ich will mich hier auf das Wesentliche beschränken und lieber ein praktisches Anwendungsbeispiel zeigen. Zudem gibt es schon viele Internet-Seiten als auch Bücher (siehe ESP8266-Buchvorstellung) die sehr viele Infos zu der ESP-Serie liefern und zum zweiten macht das Lernen einfach mehr Spaß wenn man schnell zu praktischen Ergebnissen kommt. Daher beschränke ich mich hier auf die Schritte und das Wissen, das Ihr benötigt um ein erstes erfolgreiches Projekt umzusetzen. Am Ende des Beitrages habt Ihr ein Thermometer mit Farbdisplay, das die Innentemperatur und Außentemperatur anzeigt. Auch per Browser werdet Ihr die Temperaturen abrufen können.  Basis werden zwei NodeMCU-Boards sein, wobei das eine als Empfänger / Server und Anzeige fungiert und das andere die Außentemperatur misst und zur Anzeige (zum Server) sendet.
Mit diesem Wissen dürfte es Euch dann leicht fallen auch andere und komplexere Dinge umzusetzen, bekanntlich ist der erste Schritt immer der schwierigste.

Schritt 1 – Das richtige NodeMCU-Board kaufen

Um die nachfolgenden Schritte nachzuvollziehen benötigt Ihr zunächst mal ein NodeMCU-Board. Am besten kauft Ihr euch gleich zwei, da wir später wie bereits beschrieben zwei für unser Projekt benötigen. Ihr findet geeignete Module hier bei Ebay* oder hier bei Amazon*. Achtet möglichst beim Kauf darauf, dass das Modul als USB-Wandler den Chip CP2102 verwendet, das hat nämlich den Vorteil dass Ihr unter neueren Betriebsystemen (Windows 7 / 8 / 10) keinen Treiber installieren müsst, da Windows diesen bereits besitzt. Ihr erkennt diesen Chip an der kleinen quadratischen Bauform. Man kann zwar auch die Module mit CH341-Chip einsetzen, muss dann aber einen Treiber installieren. Beim Download eines solchen Treibers muss man dann immer aufpassen dass man sich nicht versehentlich auch Viren einschleppt, was ich bei China-Downloads schon öfters mal erlebt habe. Am billigsten bekommt Ihr die Module natürlich bei Ebay* direkt aus China, allerdings müsst ihr dann auch 3 bis 4 Wochen Lieferzeit einkalkulieren.
Da ich immer etwas ungeduldig bin, habe ich auf ein Prime-Angebot von einem Amazon Händler zurückgegriffen und zwei Module von SeeedStudio gekauft. Hier sind ein paar geeignete Varianten, bei den billigsten Amazon-Angeboten wird gewöhnlich ebenfalls aus dem Ausland geliefert, also auch da die Lieferzeit beachten.

RoboMall NodeMcu V2 Lua WiFi IoT Internet Development Board ESP8266*

NodeMCU; Alle Komponenten wie USB-Seriell-Konverter

29,90 EUR

WINGONEER NodeMCU LUA WiFi Internet Development Board Basierend auf ESP8266 CP2102*

Wi-Fi: Modul ESP-12E Modul ähnlich wie ESP-12-Modul, jedoch mit 6 zusätzliche GPIOs; Leistung: 5V über Micro-USB-Anschluss

Letzte Aktualisierung am 2024-11-21 / * Affiliate Links 

Geliefert wurde das Modul innerhalb von zwei Tagen in einer ordentlichen antistatischen Verpackung, so wie man es erwartet.

Wenn Ihr das Modul auspackt, dann bemerkt Ihr wie winzig so ein NodeMCU-Board ist. Es ist ähnlich groß wie so ein Arduino-Nano, jedoch ist es es erheblich leistungsstärker und noch dazu viel günstiger.

Links ist das ESP12E-Modul und rechts der USB-Chip CP2102 und die USB-Buchse zu erkennen.

Schritt 2 – Die Arduino IDE installieren und konfigurieren

Wie schon gesagt wollen wir als Entwicklungsumgebung die Arduino IDE verwenden. Dies ist sicherlich nicht die komfortabelste Programmierumgebung, allerdings ist diese kostenlos und weit verbreitet. Die meisten Bastler (neudeutsch Maker) haben schon mal einen Arduino Uno oder ähnliches programmiert, von daher ist die Entwicklungsumgebung vielleicht ohnehin schon auf dem Rechner. Sollte das nicht der Fall sein, so könnt Ihr die IDE kostenklos über folgende Seite herunterladen

• Download – Arduino IDE

In der Regel sollte man immer die neueste Version verwenden, ich habe die Projekte und Dateien auf dieser Seite mit der Version 1.6.13 compiliert. Ihr könnt die Arduino wahlweise als ZIP-Datei  herunterladen oder eine installierbare Version wählen. Falls Ihr die ZIP-Datei wählt, dann reicht es wenn Ihr diese in ein beliebiges Unterverzeichnis entpackt. Ihr könnt danach die IDE gleich aufrufen, es muss dann nichts installiert werden. Und keine Sorge, das Ganze funktioniert auch problemlos unter Windows 10.

Die Arduino IDE unterstützt nach der Installation eine ganze Reihe von verschiedenen Arduino-Boards. Da wir aber kein Arduino Board sondern das NOdeMCU-Board programmieren möchten, müssen wir die Boardverwaltung der IDE um ein Paket bereichern.  Das geht sehr einfach, ruft dazu das im Menü Datei den Menüpunkt Voreinstellungen auf.
Dort gibt es das Eingabefeld Zusätzliche Boardverwalter URL´s. Dort gebt ihr die unten aufgeführte Url ein und schließt danach den Dialog wieder mit OK.

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Das ganze sollte also in etwas so aussehen wir unten im Bild:

Wichtig – ESP8266-Module in die Boardverwaltung aufnehmen

Nachdem Ihr die Voreinstellungen wieder mit OK verlassen habt, könnt Ihr im Menü Werkzeuge den Menüpunkt Board… und danach Boardverwaltung auswählen.

In der Boardverwaltung sucht Ihr jetzt nach ESP8266, in der Regel solltet Ihr es auch finden wenn ihr dort ganz nach unten scrollt. Wenn Ihr darauf klickt, dann erscheint ein Auswahlfeld für die Version und ein Installieren-Button.

Achtung, manchmal macht die Version 2.3 Probleme

Die Installation des ESP-Paketes besteht aus sehr vielen Dateien, daher kann der Installationsvorgang je nach Rechner durchaus  1 bis 2 Minuten dauern, also Geduld! Danach könnt ihr die Boardverwaltung wieder schließen, die Arduino IDE ist nun bereit um zahlreiche ESP8266-Module, aber auch das NodeMCU-Board zu programmieren.

Schritt 3 – NodeMCU-Board per USB mit der Arduino IDE verbinden

Nun müssen wir der Arduino-IDE noch mitteilen welches Board wir genau programmieren möchten. Dazu gehen wir noch mal über Menü Werkzeuge und Board… auf den Menüpunkt “NodeMCU 1.0 (ESP-12E-Module)“.

So, nun müssen wir der IDE nur noch mitteilen an welchem COM-Port das Modul angeschlossen ist, denn der USB-Treiber gibt die Daten über virtuellen COM-Port an die IDE weiter. Man könnte jetzt im Gerätemanager von Windows nachschauen welche COM-Ports dort bereitgestellt werden. Gewöhnlich reicht es aber wenn Ihr in der Arduino IDE über Werkzeuge auf den Menüpunkt Port geht. Gewöhnlich wird dort angezeigt welcher COM-Port jetzt bereit steht. Wenn es nur einer ist, dann ist die Auswahl ja sehr einfach.

Bei den meisten NodeMCU-Boards können Programme mit 115200 Baud übertragen werden, diese Übertragungsgeschwindigkeit ist gewöhnlich bereits in der IDE vorgegeben. Es soll aber auch NodeMCU Boards geben, die auf eine andere Geschwindigkeit eingestellt sind, sollte es also später Probleme mit dem Upload geben, versucht mal eine andere  Geschwindigkeit unter Menüpunkt Werkzeuge/Upload Speed.

Schritt 4 – Wie schreiben unser erstes Programm für das NodeMCU-Board

Jetzt sind wir soweit, wir können unser erstes Programm für das NodeMCU-Board schreiben. Wie üblich, fangen wir mal mit einer blinkenden LED an. Dazu müssen wir noch nicht mal eine LED anschließen, denn das Board verfügt am Port D0 über eine LED auf dem Modul. Dieser Port ist frei und kann nach Belieben programmiert werden. Mit dem unteren Sketch bringt ihr diese LED im Sekundentakt zum Blinken.
Kopiert den Sketch in eure Arduino-IDE, speichert diesen und übertragt ihn per Klick auf den Pfeil auf das NodeMCU Board.

Programm (Sketch) compilieren und übertragen

Die Compilierung und Übertragung eines Programmes dauert bei den ESP-Modulen als auch bei dem NodeMCU-Board wesentlich länger als bei den kleinen Arduino-Programmen, da im Hintergrund wesentlich mehr Code compiliert werden muss. Wundert Euch also nicht wenn die Compilierung , je nach Rechner schon mal 30 bis 60 Sekunden dauert.

Unten seht Ihr den Programmcode des ersten LED-Beispiels. Wenn nach der Übertragung auf euer Board die Led langsam blinkt, dann hat alles geklappt. Wenn Ihr Ports im Programm ansprecht, achtet darauf ob ihr die NodeMCU Nummer oder den GPIO-Port angebt. So entspricht beispielsweise die Bezeichnung D1 dem Port GPIO16. Wenn nur Zahlen im Sketch angegeben werden, dann ist das immer die GPIO-Nummer. Bei der NodeMCU-Nummerierung müsst Ihr das D davor schreiben. Also nicht verwechseln!
Ansonsten ist zu dem Programm wohl nichts zu sagen,es erklärt sich eigentlich von selbst, ein Arduino-Programm sieht ja auch nicht anders aus. Man kann also so ein ESP-Board wie ein Arduino programmieren, man muss sich also gar nicht umstellen.

Eine Besonderheit, der Der yield() – Befehl

Eine kleine Einschränkung muss ich dabei aber doch an dieser Stelle erwähnen. Da sich der ESP-Chip im Hintergrund immer auch um das WLAN kümmern muss, darf der ESP-Chip durch eigene Programme nie länger als 20 ms an einem Stück blockiert werden. Diese Einschränkung hört sich erst mal gewaltig an, ist es aber nicht. Es reicht wenn bei längeren Schleifen oder Operationen ein yield()  oder delay(…) – Befehl eingefügt wird. Denn yield() gibt dem Chip wieder Zeit für seine Aufgaben. Würde der ESP-Chip nicht mehr genügend Zeit bekommen, so würde er sich aufhängen, also nicht mehr reagieren.  In vielen Fällen braucht man sich aber auch darum gar nicht zu kümmern wie in unserem LED-Beispiel. Das liegt daran, dass der yield()  Befehl inzwischen auch in anderen Funktionen der Library, wie z.B. dem Befehl delay selbst schon aufgerufen wird.
Würdet Ihr jetzt aber eine Endlosschleife ohne delay und yield programmieren, so wäre ein Absturz sicher. Also im Zweifel bei Schleifen die länger als 20ms dauern, zumindest ein yield oder delay einfügen.

Blinkende LED – das erste Programm für das NodeMCU-Board

/*
 NodeMCU-BlinkendeLED
 Led an dem Modul ESP8266 bzw. Board NodeMCU blinken lassen
 Programm erprobt ab Arduino IDE 1.6.13
 Weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
 */

#define LED D0 //GPIO16 Interne Led auf dem NodeMCU Board 
               //oft auch bereits als LED_BUILTIN definiert
               //man koennte auch schreiben #define LED  16 (was das gleiche ist)

               // #define LED D7 //nur Falls du externe LED z.B. an D7 (GPIO13)
               // über ca. 330 Ohm Widerstand angeschlossen hast auskommentieren

void setup() {
 pinMode(LED, OUTPUT); // Port aus Ausgang schalten
 }

void loop() {
 digitalWrite(LED, LOW); //Led port ausschalten
 delay(1000); //1 Sek Pause
 digitalWrite(LED, HIGH); //Led port einschlaten
 delay(1000);
 }

Schritt 5 – NodeMCU ganz neu mit Lua-Firmware flashen

Diesen Schritt müsst Ihr nur machen, falls sich euer NodeMCU-Board komisch verhält bzw. die Programme nicht korrekt ablaufen. Ihr könnt den Schritt aber auch dann machen, wenn Ihr mal in Lua-programmieren wollt. Bei dem Flashen wird die ursprüngliche Lua-Firmware aufgespielt und das Modul richtig konfiguriert.

Auch hierfür gibt es ein Tool für Windows, das praktisch alles automatisch macht und auch bereits die richtige Firmware beinhaltet. Ihr müsst es quasi nur auf euren Rechner laden und aufrufen. Es müssen keinerlei Tasten gedrückt oder Angaben gemacht werden, wie es noch bei älteren Tutorials beschrieben wird. Nach dem Start müsst Ihr lediglich den Com-Port des NodeMCU-Boards auswählen und auf FLASH klicken, alles weitere geht automatisch.

• Download – Flash-Tool mit integrierter Lua Firmware

Nachdem Ihr euer gekauftes NodeMCU neu geflasht habt, könnt Ihr also zurück zu Schritt 4 gehen und das Ganze noch mal versuchen. Spätestens jetzt sollte eigentlich alles klappen.
Falls du auch mal unter Lua-Programmieren willst, dann kann ich übrigens folgende Links empfehlen:

• NodeMCU – Dokumentation (englisch)
• NodeMCU / Lua tutorial (englisch)
• Offizielle Lua Hompage (englisch)
• Deutsche Übersetzung der Lua Doku
• Buch Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer (deutsch)*  / Review auch hier

Mit der NodeMCU-Programmierung loslegen

Mit NodeMCU_Board Temperatursensor DS 18B20 auslesen

Digitaler Temperatursensor DS18S20

Natürlich kann man bei einem NodeMCU Board auch andere Arduino Libraries einbinden und sich so oft viel Programmierarbeit ersparen. Insbesondere wenn man Sensoren ausließt oder LCD´s ansteuert, macht es Sinn auf vorhandene Libraries zurückzugreifen. Doch Vorsicht, einige Libraries funktionieren nicht mit dem NodeMCU-Board. Das hat auch mit der weiter oben erwählten yield()-Problematik zu tun, Libraries, die für andere Boards entwickelt wurden, kannten das natürlich nicht.
Inzwischen liegen aber viele Libraries auch in einer speziell angepassten Form vor, achtet also immer darauf ob eine speziell angepasste Version notwendig ist, in der Regel geben das die Autoren im Quellcode/Sketch oder dem jeweiligen Blog an (zumindest sollte es so sein).
Ein Beispiel ist die Libary DallasTemperature, die zum Auslesen des beliebten Temperatursensors  DS18B20 Verwendung findet. Wenn diese Library in einem Sketch gebraucht wird (wie im folgenden Code), dann müsst Ihr euch die Ersatz Library auf dieser Seite  herunterladen und installieren:

• Ersatz für DallasTemperature  https://github.com/milesburton/Arduino-Temperature-Control-Library

Falls Ihr bereits die normale DallasTemperature-Lib installiert habt, müsst Ihr diese deinstallieren oder einfach aus dem Verzeichnis C:\Users\DeinBenutzername\Documents\Arduino\libraries  löschen. Ansonsten weiß die Arduino IDE nicht welche sie benutzen soll und nimmt die falsche. Oft wird das beim Compilieren als Warnung zwar angezeigt, jedoch auch überlesen da es schnell weg gescrollt wird.

Die Onwire und Base-Library dagegen, die auch in dem nachfolgenden Beispiel Verwendung findet, kann ganz normal und bequem über die Arduino-IDE (Menüpunkt Sketch / Bibliothek einbinden) heruntergeladen und installiert werden.

Das nachfolgende Beispiel liest den Temperatursensor  DS18B20 aus und gibt die Temperatur über die serielle Schnittstelle im 2 Sekunden Takt  aus. Nachdem Ihr das Programm übertragen habt, könnt ihr den “Seriellen Monitor” der Arduino IDE starten und die Temperaturausgaben verfolgen.
Die seriellen Monitor zum Überwachen der NodeMCU Ausgaben startet Ihr mit dem Lupensymbol rechts oben in der Arduino IDE, siehe Foto.

Die Ausgaben sollten bei unserem jetzigen Beispiel (unterer Sketch) in etwa wie unten abgebildet aussehen. Erscheinen dort unleserliche Zeichen, dann müsst ihr in der rechten unteren Ecke eventuell die Baudrate anders wählen. Die eingestellte Baudrate muss der Baudrate entsprechen, die ihr im Sketch mit folgendem Befehl angegeben habt:

Serial.begin(115200);

Hier die Schaltung:

Hier der Programmcode (Sketch)

/*
 NodeMCU-DallasDS18B20
 Led an dem Modul ESP8266 bzw. Board NodeMCU blinken lassen
 und Temperatursensor an Pin D1 auslesen
 
 Notwendig ist die angepasste Dallas-Lib: 
   Download hier: https://github.com/milesburton/Arduino-Temperature-Control-Library
   Eine eventuell vorhandene DallasTemperature-Lib sollte gelöscht werden, damit oben 
   genannte von der IDE verwendet wird
 
 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX 
 Bezugsquelle NodeMCU Board: http://amzn.to/2iRkZGi

 Programm erprobt ab Arduino IDE 1.6.13
 Weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/

#define LED D0 //Interne Led auf dem NodeMCU Board LED_BUILTIN

#include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird 
                            //https://github.com/milesburton/Arduino-Temperature-Control-Library
#include <Base64.h>
#include <OneWire.h>

#define ONE_WIRE_BUS D1  //Bestimmt Port an dem der Sensor angeschlossen ist

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);

char temperaturStr[6];

void setup() {
 pinMode(LED, OUTPUT); // Port aus Ausgang schalten
 Serial.begin(115200);
 DS18B20.begin();
}

float getTemperatur() {
 float temp;
 do {
 DS18B20.requestTemperatures(); 
 temp = DS18B20.getTempCByIndex(0);
 delay(100);
 } while (temp == 85.0 || temp == (-127.0));
 return temp;
}

void loop() {
 digitalWrite(LED, LOW); //Led port ausschalten
 delay(1000); //1 Sek Pause
 digitalWrite(LED, HIGH); //Led port einschlaten
 delay(1000); 

 float temperatur = getTemperatur();
 dtostrf(temperatur, 2, 2, temperaturStr);
 Serial.print("Temperatur: "); 
 Serial.println(temperaturStr); 

}

NodeMCU steuert QVGA-Farbdisplay an und gibt Temperatur aus

Wir haben gesehen wie einfach man so ein NodeMCU-Board* programmieren kann und wie einfach man Ausgaben über das USB-Kabel zum PC zurückschicken und anzeigen lassen kann. Natürlich wäre es viel schöner wenn man die Temperatur oder auch andere Dinge auf einem eigenen kleinen Display ausgeben könnte. Auch das ist kein Problem, im nachfolgende Sketch steuern wir ein Grafik-Farbdisplay per SPI an. Ein solches Display bekommt man z.B. für ein paar Euro bei Amazon* oder Ebay*. Das Beispiel funktioniert aber auch bei ähnlichen Displays die den selben Displaycontroller ILI9340 nutzen.

Keine Produkte gefunden.

Auf der Rückseite sieht ein solches Display zum Beispiel so aus:

Viele dieser Displays haben auch einen Sockel für eine SD-Karte auf der Rückseite, um das Beispiel einfach zu halten nutzen wir diesen im unteren Sketch nicht. Die Ansteuerung ist dadurch relativ einfach und der Sketch sehr übersichtlich, da wir auch hier wieder auf vorhandene Arduino Libraries zurückgreifen können. Für das Beispiel brauchen wir zusätzlich folgende Libraries:

• Adafruit_GFX
• Adafruit_ILI9340

Die erste kann wieder bequem über die Arduino-IDE installiert werden. Die zweite wird wieder in einer für NodeMCU (bzw. ESP8266) angepassten Version benötigt, diese kann man hier herunterladen:

• Adafruit_ILI9340 – Angepasst für NodeMCU/ESP8266 – https://github.com/glennirwin/Adafruit_ILI9340

Schaltplan / Skizze – NodeMCU mit Display und Tmperatursensor DS18B20

Wie das Ganze verschaltet wird, sieht man auch unten in der Schaltungsskizze.

Display     Verbunden mit
VCC         3,3V
GND         GND
CS          GND
RST         RESET
D/C         D1
SDI/MOSI    D7
SCK         D5
LED         3,3 V
SDO/MISO    D6

Unser neuer Programmcode (Sketch) für die Display Ansteuerung und Temperaturanzeige

Das NodeMCU-Board misst zwei mal pro Sekunde die Temperatur. Ergibt sich eine Temperaturveränderung so wird diese auf dem Display ausgegeben. Wir haben also ein elektronisches Thermometer, welches sehr genau ist. Die Temperatur wird mit einer Nachkommastelle ausgegeben. Das Beispiel ist bewusst einfach gehalten, man könnte die Ausgabe natürlich noch hübscher gestalten, die Grafik Library bietet dafür zahlreiche Befehle die man verwenden könnte.

/*
 NodeMCU-TFT-Temperatur
 
 TFT-Display mit Controller ILI9341 am NodeMCU-Board
 Verwendetes Display: 2.2 Zoll Serial TFT-Farbdisplay; SPI; Auflösung 240x320 Pixel 
 Bezugsquellen Display:
 Amazon - http://amzn.to/2iNmaXx / Amazon - http://amzn.to/2j1VIXK
 
 Temperatur wird über angeschlossenen Sensor DS18B20 ausgelesen und auf dem Display angezeigt
 Temperatursensor DS18B20 an Pin D2 
 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX 
 
 Notwendig ist die angepasste Display-Lib: https://github.com/glennirwin/Adafruit_ILI9340
 
 Programm erprobt ab Arduino IDE 1.6.13
 Projektbeschreibung und weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/

#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9340.h" // https://github.com/glennirwin/Adafruit_ILI9340
#include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird https://github.com/milesburton/Arduino-Temperature-Control-Library
#include <Base64.h>
#include <OneWire.h>

#define ONE_WIRE_BUS D2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);

char temperaturStr[6];
float merketemperatur=0;

//Pinbelegung für Display

#define TFT_CS D0   // GPIO 16 interne LED kein Port nötig, da TFT CS an GND
#define TFT_RST 10  // D12 GPIO10 //kein Port nötig, da Reset an Reset angeschlossen
#define TFT_DC D1   // GPIO 5
#define TFT_MOSI D7 // GPIO 13
#define TFT_CLK D5  // GPIO 14
#define TFT_MISO D6 // GPIO 12

Adafruit_ILI9340 tft = Adafruit_ILI9340(TFT_CS, TFT_DC, TFT_RST);

//Falls die Anzeige gedreht wird
#define ROTATION_NO 0
#define ROTATION_90 1
#define ROTATION_180 2
#define ROTATION_270 3

void setup() 
{
 DS18B20.begin();

 Serial.begin(115200);
 
 tft.begin();
 
 tft.setRotation( ROTATION_270);
 tft_zeichneRahmen();
 tft_zeichneBeschriftung();
}


void tft_zeichneBeschriftung(void)
{
 tft.setTextColor(ILI9340_WHITE); 
 tft.setCursor( 10,55);
 tft.setTextSize(2); 
 tft.print("Innentemperatur in ");
 tft.setTextSize(1); 
 tft.print("O");
 tft.setTextSize(3); 
 tft.print("C");

 tft.setTextSize(1); 
 tft.setCursor( 50,15);
 tft.print("www.Mikrocontroller-Elektronik.de");
 tft.setTextSize(2); 
 tft.setCursor( 10,210);
 tft.print("NodeMCU Beispiel");
}

void tft_zeichneRahmen( )
{
 tft.fillScreen(ILI9340_BLACK);
 tft.drawRoundRect(1, 0, tft.width()-1,40, 10, ILI9340_BLUE);
 tft.drawRoundRect(1, 50, tft.width()-1,135, 10, ILI9340_GREEN);
 tft.drawRoundRect(0, 200, tft.width()-1, 40, 10, ILI9340_RED);
 }

float getTemperatur() {
 float temp;
 do {
 DS18B20.requestTemperatures(); 
 temp = DS18B20.getTempCByIndex(0);
 delay(100);
 } while (temp == 85.0 || temp == (-127.0));
 return temp;
}

void zeigeTemperatur(float temperatur)
{
 dtostrf(temperatur, 2, 1, temperaturStr);
 Serial.print("Temperatur: "); 
 Serial.println(temperaturStr); 
 tft.setTextSize(10); 
 tft.setTextColor(ILI9340_YELLOW, ILI9340_BLACK ); 
 tft.setCursor(20,90);
 tft.print(temperaturStr);
 
}

void loop(void) 
{
 delay(500); 
 float temperatur = getTemperatur();
 if (merketemperatur!=temperatur) {
 zeigeTemperatur(temperatur);
 merketemperatur=temperatur;
 }

}

Wir programmieren einen ESP-Server und ESP-Client um Temperaturwerte per WLAN zu übertragen

Wir haben jetzt zwar mit der Temperaturanzeige schon ein erste praktisches Beispiel gesehen was mit dem NodeMCU-Board umgesetzt werden kann, allerdings wurden bislang noch nicht die eigentlichen WLAN-Fähigkeiten verwendet. Alles was wir bisher gemacht haben wäre auf einem Arduino Uno genauso möglich gewesen. Jetzt wollen wir aber auch noch die Außentemperatur mit auf die Anzeige bringen und dazu können wir WLAN einsetzen.
Wir werden also zwei NodeMCU-Boards einsetzen, eines immer Innenbereich für die Anzeige und eines um die Außentemperatur zu messen und per WLAN zu übertragen.

Die ESP-Module bzw. NodeMCU kann in mehreren Betriebsarten verwendet werden. Es kann als Server, Access-Point oder Client konfiguriert werden. Es gibt also gleich mehrere Möglichkeiten unser Vorhaben umzusetzen.

Wir haben folgende Konstellation gewählt:

Unsere Außenstation, welche die Außentemperatur ermittelt, wird als Client arbeiten. Hier wird also nur ein Temperatursensor an das NodeMCU-Board angeschlossen, praktisch wie in unserem ersten Beispiel.
Das zweite NodeMCU-Board wird mit einem Temperatursensor für den Innenbereich und dem Farbdisplay verdrahtet, also genauso wie oben im letzten Beispiel.
Im Grunde brauchen wir also nur den Programmcode zu verändern um unser Ziel zu erreichen.

Das NodeMCU-Board im Innenbereich werden wir im Sketch so konfigurieren, dass es als Server fungiert und sich in ein vorhandenes WLAN-Netz integriert. Wir werden dem Board im Sketch eine feste IP geben, so dass wir stets wissen wie unser Board mit dem Display erreichbar ist.

Ihr müsst also in dem unteren Sketch die SSID und das Passwort eures hauseigenen WLAN-Netzes eintragen (entsprechende Stellen sind mit einem Kommentar versehen).

Das NodeMCU-Board im Außenbereich braucht ebenfalls eure WLAN-Zugangsdaten, die IP kann hier aber dynamisch über den Router (DHCP-Server) geholt werden. Damit sich der Strombedarf in Grenzen hält, wird dieses Board die Temperatur in zeitlichen Abständen von 15 Minuten an den Server übertragen. Die Zeit könnt ihr im Sketch frei einstellen. Zwischen diesen Zeiten wird sich das Board schlafen legen.

Als Übertragungsart nutzen wir quasi einen URL-Aufruf, bei dem die Temperaturwerte von außen an den Server mit Display übertragen werden. Dies hat den Vorteil, dass die Werte sehr leicht beim Server dekodiert werden können und zudem könnt Ihr probeweise auch per Browser Daten zur Anzeige übertragen.

Eine solche Aufruf würde wie folgt aussehen:

http://192.168.2.75/sensor/temperatur/?wert=20

Bei diesem Aufruf gehen wir davon aus, dass Ihr eurem NodeMCU- Server die feste IP 192.168.2.75 zugeteilt habt, ihr könnt natürlich auch eine andere verwenden. Wir haben hier als Unterseite „/sensor/temperatur/“ bei Server definiert, eure Temperatur, die hier als „wert=20“ übergeben wird, wird nach Eingabe der URL sofort am Server empfangen und auf dem Display angezeigt. Das hilft beim debuggen.

Man könnte natürlich noch weitere Werte übertragen, beispielsweise mit diesem Aufruf:

http://192.168.2.75/sensor/temperatur/?pw=passwortxyz&nr=1&wert=20

Man könnte also zum Beispiel auch ein Passwort mit angeben, damit Fremde, welche die URL kennen, nicht missbräuchlich unberechtigte Daten übertragen. Der Server könnte also beispielsweise alle Aufrufe mit falschen Passwort einfach ignorieren. Der Übersichtlichkeit halber werden momentan Passort und weitere Parameter nicht ausgewertet, sind aber möglich.

Die fertige Schaltung für unseren Außensensor mit WLAN-Sender

Wichtig zum Aufwecken nach dem Tiefschlaf , die blaue Drahtbrücke zwischen Reset und D0 (GPIO16)

Unser Programm (Sketch) für den Außensensor

Der Sketch für das NodeMCU-Board im Außenbereich sieht also nun wie folgt aus.

/*
 NodeMcu-Client-Aussentemperatur

 Temperatur wird über angeschlossenen Sensor DS18B20 ausgelesen und per 
 Url an einen Server uebertragen.
 Als Server (also Empfaenger) kann ebenfalls ein NodeMcu-Board verwendet werden.
 Ein Beispiel-Empfaenger empfehlen wir das Script "NodeMCU-Server-TFT-Temperatur" auf unser
 Projektseite. Dieses gibt die empfangene Temperatur als auch lokale Temperatur auf einem
 QVGA-Farbdisplay aus.
 Die Temperatur wird nur alle 15 Minuten übertragen um Energie zu sparen und Batterie
 Betrieb zu ermöglichen. Zwischendurch legt sich das Board schlafen.
 
 Temperatursensor DS18B20 an Pin D2 
 
 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX 
 Bezugsquelle NodeMCU Board: http://amzn.to/2iRkZGi
 Notwendige Lib:
 https://github.com/milesburton/Arduino-Temperature-Control-Library
 
 Programm erprobt ab Arduino IDE 1.6.13
 Projektbeschreibung und weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/

#include <ESP8266WiFi.h>
#include <DallasTemperature.h> //Siehe Hinweis oben, 
      //verwendet wird https://github.com/milesburton/Arduino-Temperature-Control-Library
#include <Base64.h>
#include <OneWire.h>

#define ONE_WIRE_BUS D2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);

const char* ssid = "EURE-SSID"; //Hier SSID eures WLAN Netzes eintragen
const char* password = "EUER-WLANPASSWORT"; //Hier euer Passwort des WLAN Netzes eintragen

const char* host = "192.168.2.75"; //Server der die temperatur empfangen soll 
                                   //(er sollte feste IP haben)
const char* script = "/sensor/temperatur/"; //URL/Verzeichnis das wir gewaehlt haben

const char* passwort = "passwortxyz"; //Passwort, derzeit ungenutzt
const char* idnr = "1"; //Hier kann man dem Sensor eine beliebe ID zuteilen (derzeit ungenutzt)
 

#define LED D0 //Interne Led auf dem NodeMCU Board LED_BUILTIN

void setup() {
 DS18B20.begin(); 
 Serial.begin(115200);
 delay(10);

 Serial.println();
 Serial.println();
 Serial.print("Verbinde mich mit Netz: ");
 Serial.println(ssid);
 
 WiFi.begin(ssid, password);
 
 while (WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print(".");
 }

 Serial.println("");
 Serial.println("WiFi Verbindung aufgebaut"); 
 Serial.print("Eigene IP des ESP-Modul: ");
 Serial.println(WiFi.localIP());
}

//Funktion um Innentemperatur zu ermitteln
float getTemperatur() {
 float temp;
 do {
   DS18B20.requestTemperatures(); 
   temp = DS18B20.getTempCByIndex(0);
   delay(100);
 } while (temp == 85.0 || temp == (-127.0));
 return temp;
}


//In unserem Beispiel wird die loop Schleife eigentlich nur einmal durchlaufen
void loop() {

 char temperaturStr[6];
 float temperatur = getTemperatur();
 dtostrf(temperatur, 2, 1, temperaturStr);
 Serial.print("Temperatur: "); 
 Serial.println(temperaturStr); 
 
 int versuche=1; 
 WiFiClient client;
 const int httpPort = 80;
 int erg;
 do
 {
   Serial.print("Verbindungsaufbau zu Server ");
   Serial.println(host);

   erg =client.connect(host, httpPort);
   if (!erg) {
     versuche++; 
     Serial.println("Verbindungsaufbau nicht moeglich!!!");
     if (versuche>3){
       Serial.println("Klappt nicht, ich versuche es spaeter noch mal!");
       client.stop();
       WiFi.disconnect(); 
       ESP.deepSleep( 10*60000000); //Etwas später neu probieren, solange schlafen
     }
   }
   delay(1000);
 } while (erg!=1);
 
 String url = script; //Url wird zusammengebaut
 url += "?pw=";
 url += passwort;
 url += "&idnr=";
 url += idnr;
 url += "&wert=";
 url += temperaturStr;
 
 Serial.print("Folgende URL wird aufgerufen: ");
 Serial.println(host + url);
 
 client.print(String("GET ") + url + " HTTP/1.1\r\n" +
 "Host: " + host + "\r\n" + 
 "Connection: close\r\n\r\n");
 unsigned long timeout = millis();
 while (client.available() == 0) {
   if (millis() - timeout > 5000) {
      Serial.println("Timeout!");
      Serial.println("Uebergabe klappt nicht, ich versuche es spaeter noch mal!");
      client.stop();
      WiFi.disconnect(); 
      ESP.deepSleep( 60*1000000); //Etwas später 60 Sekunden neu probieren,solange schlafen
   }
 }

 Serial.print("Rueckgabe vom Server:\n");
 while(client.available()){
   String line = client.readStringUntil('\r');
   Serial.print(line);
 }

 client.stop();
 WiFi.disconnect(); 
 Serial.println("\nVerbindung beendet");
 
 Serial.print("Schlafe jetzt ...");
 ESP.deepSleep( 15*60000000); //Angabe in Minuten - hier 15
}

Der Code ist extra sehr einfach gehalten und enthält viele Kommentare und Ausgaben für die serielle Schnittstelle, einfach damit Ihr ihn besser versteht. Man könnte natürlich alle seriellen Ausgaben weglassen, da später im Außenbereich diese Ausgaben sowieso niemand mehr empfängt.

Kurz noch mal zur Funktion:

Nach dem Start des Sketches baut das NodeMCU-Board die Verbindung zum WLAN-Netz auf, Danach liest es die Temperatur des Sensors aus. Dann baut es eine Verbindung zum angegebenen Server (euer NodeMCU im Innenbereich) auf und übergibt die Temperatur mit diesem URL-Aufruf:

http://192.168.2.75/sensor/temperatur/?pw=passwortxyz&nr=1&wert=20

Klappt das nicht, wird das 3 mal wiederholt. Erst danach legt sich das Board 10 Minuten schlafen. Nach diesen 10 Minuten beginnt das gleiche wieder von vorne. Hat die Übergabe per URL geklappt, dann schläft das Board 15 Minuten.

Das Schlafenlegen des NodeMCU-Boards erfolgt mit dem Befehl:

ESP.deepSleep( 15*60000000); //15 Minuten Modul schlafen legen

Das Schlafen des Boards dient natürlich dazu Strom einzusparen. Wie bereits erwähnt benötigt der ESP8266-Chip im DeepSleep Mode angeblich unter 1µA, also so gut wie kein Strom. Dies gilt allerdings nicht für das NodeMCU-Board, da hier ja noch weitere Bauelemente wie Spannungsregler und USB-Chip vorhanden sind. Hier habe ich bislang nur einen Mindeststrombedarf von ca. 18mA hin bekommen. Das ist leider immer noch recht hoch, eine Batterie wird daher in einigen Tagen auch leer sein. Daher bietet sich das NodeMCU-Board im Außenbereich eigentlich nur an, wenn es mit Netzgerät oder Solarenergie versorgt wird.
Empfehlenswert ist es aber sicherlich, das fertige NodeMCU-Board Programm nach der Entwicklung in den ESP-12E Modul direkt einzuspielen. Man kann dann auf stromintensive Zusatzbauteile verzichten. Der Übersichtlichkeit halber, bleiben wir in unserem Tutorial aber bei dem NodeMCU-Board.

Übrigens, statt mit URL das interne NodeMCU-Board aufzurufen, könnte man auf gleiche Weise auch ein PHP-Script auf einem Server irgendwo im Internet aufrufen. Dazu müsst Ihr einfach nur die IP in der URL austauschen. Ein solches Script könnte die Temperaturen in einer Datenbank oder Textdatei protokollieren oder auch auf einer Webseite anzeigen.

Programm für den Server mit Display und Innentemperaturmessung

Bei der Schaltung für den Server der auch gleichzeitig die Innentemperatur misst und beide Temperaturen auf einem Display anzeigt, hat sich eigentlich nur das Programm geändert. Es werden jetzt natürlich zwei Temperaturwerte angezeigt.

Der neue NodeMCU-Server zeigt jetzt natürlich beide Temperaturen an

Hier nun der neue Sketch für diesen Server:

/*
 NodeMCU-Server-TFT-Temperatur

 NodeMCU fungiert als Server und empfängt Temperatur per URL
 Temperaturwerte (z.B. Außentemperatur) wird auf angeschlossenem 
 QVGA-Display ausgegeben,
 
 Parameteruebergabe-Syntax:
 http://192.168.2.75/sensor/temperatur/?pw=passwortxyz&idnr=1&wert=20
 
 Verwendetes Display: 2.2 Zoll Serial TFT-Farbdisplay; SPI; Auflösung 240x320 Pixel 
 Bezugsquellen Display:
 Amazon - http://amzn.to/2iNmaXx / Amazon - http://amzn.to/2j1VIXK

 Temperatur wird über angeschlossenen Sensor DS18B20 ausgelesen und auf dem Display angezeigt
 Temperatursensor DS18B20 an Pin D2 
 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX 
 
 Notwendig ist die angepasste Display-Lib: https://github.com/glennirwin/Adafruit_ILI9340
 
 Programm erprobt ab Arduino IDE 1.6.13
 Projektbeschreibung und weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/


#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9340.h" //verwendete Lib für Display https://github.com/glennirwin/Adafruit_ILI9340
#include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird https://github.com/milesburton/Arduino-Temperature-Control-Library
#include <Base64.h>
#include <OneWire.h>

#define ONE_WIRE_BUS D2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);

float merketemperatur=0;
float merkeaussentemperatur=0;

//Pinbelegung für Display

#define TFT_CS D0 //GPIO 16 interne LED kein Port nötig, da TFT CS an GND
#define TFT_RST 10 //D12 GPIO10 //kein Port nötig, da Reset an Reset angeschlossen
#define TFT_DC D1 // GPIO 5
#define TFT_MOSI D7 // GPIO 13
#define TFT_CLK D5 // GPIO 14
#define TFT_MISO D6 // GPIO 12

Adafruit_ILI9340 tft = Adafruit_ILI9340(TFT_CS, TFT_DC, TFT_RST);

//Falls die Anzeige gedreht wird
#define ROTATION_NO 0
#define ROTATION_90 1
#define ROTATION_180 2
#define ROTATION_270 3

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

const char* ssid = "DEINE_SSID"; //Ihr Wlan,Netz SSID eintragen
const char* pass = "DEIN_WLANPASSWORT"; //Ihr Wlan,Netz Passwort eintragen
IPAddress ip(192,168,2,75); //Feste IP des neuen Servers, frei wählbar
IPAddress gateway(192,168,2,1); //Gatway (IP Router eintragen)
IPAddress subnet(255,255,255,0); //Subnet Maske eintragen

ESP8266WebServer server(80);

void handleRoot() {
 //Temperatur auch bei Url-Aufruf zurückgeben
 String message="*** Ueberwachungs Server - Beispiel von www.mikrocontroller-elektronik.de ***\n";
 String tempstr= String(merketemperatur, 2); 
 message += "Temperatur Innen : " + tempstr +"\n";
 tempstr= String(merkeaussentemperatur, 2); 
 message += "Temperatur Aussen: " + tempstr +"\n";
 server.send(200, "text/plain", message);
}


void handleTemperatur() {
 //printUrlArg(); //fuer Debugz Zwecke

 String stemp =server.arg("wert");
 float temperatur = stemp.toFloat();
 if (merkeaussentemperatur!=temperatur) {
 zeigeAussenTemperatur(temperatur);
 merkeaussentemperatur=temperatur;
 }

 //Temperatur auch bei Url-Aufruf zurückgeben
 String message="*** Ueberwachungs Server - Beispiel von www.mikrocontroller-elektronik.de ***\n";
 String tempstr= String(merketemperatur, 2); 
 message += "Temperatur Innen : " + tempstr +"\n";
 tempstr= String(merkeaussentemperatur, 2); 
 message += "Temperatur Aussen: " + tempstr +"\n";
 server.send(200, "text/plain", message);
}


void printUrlArg() {
 //Alle Parameter seriell ausgeben
 String message="";
 for (uint8_t i=0; i<server.args(); i++){
 message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
 }
 server.send(200, "text/plain", message);
 Serial.println(message);
}

 
void setup() {

 DS18B20.begin(); //lokale Temperaturmessung
 
 Serial.begin(115200);
 Serial.println(" \r\nINIT \r\n") ;

 WiFi.begin(ssid, pass);
 WiFi.config(ip, gateway, subnet);
 while (WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print(".");
 } 
 Serial.println("");
 Serial.print("Verbunden mit ");
 Serial.println(ssid);
 Serial.print("IP address: ");
 Serial.println(WiFi.localIP());
 
 server.on("/",handleRoot) ;
 server.on("/sensor/temperatur/", handleTemperatur);
 server.begin();
 
 Serial.println("HTTP Server wurde gestartet!");

 tft.begin();
 tft.setRotation( ROTATION_270);
 tft_zeichneRahmen();
 tft_zeichneBeschriftung();
 
}


void tft_zeichneBeschriftung(void)
{
 tft.setTextColor(ILI9340_WHITE); 
 tft.setCursor( 10,5);
 tft.setTextSize(2); 
 tft.print("Innentemperatur");

 tft.setCursor( 285,5);
 tft.setTextSize(1); 
 tft.print("O");
 tft.setTextSize(3); 
 tft.print("C");


 tft.setTextColor(ILI9340_WHITE); 
 tft.setCursor( 10,127);
 tft.setTextSize(2); 
 tft.print("Aussentemperatur");

 tft.setCursor( 285,127);
 tft.setTextSize(1); 
 tft.print("O");
 tft.setTextSize(3); 
 tft.print("C");
}


void tft_zeichneRahmen( )
{
 
 tft.fillScreen(ILI9340_BLACK);
 
 tft.drawRoundRect(0, 0, tft.width()-1,117, 10, ILI9340_GREEN);
 tft.drawRoundRect(0, 122, tft.width()-1,117, 10, ILI9340_BLUE); 
}


float getTemperatur() {
 float temp;
 do {
 DS18B20.requestTemperatures(); 
 temp = DS18B20.getTempCByIndex(0);
 delay(100);
 } while (temp == 85.0 || temp == (-127.0));
 return temp;
}

void zeigeTemperatur(float temperatur)
{
 char temperaturStr[6];
 dtostrf(temperatur, 2, 1, temperaturStr);
 Serial.print("Temperatur: "); 
 Serial.println(temperaturStr); 

 tft.setTextSize(10); 
 tft.setTextColor(ILI9340_MAGENTA, ILI9340_BLACK ); 
 tft.setCursor(20,30);
 tft.print(temperaturStr);
 
}

void zeigeAussenTemperatur(float temperatur)
{
 char temperaturStr[6];
 dtostrf(temperatur, 2, 1, temperaturStr);
 Serial.print("AussenTemperatur: "); 
 Serial.println(temperaturStr); 
 
 tft.setTextSize(10); 
 tft.setTextColor(ILI9340_YELLOW, ILI9340_BLACK ); 
 tft.setCursor(20,152);
 tft.print(temperaturStr);
 
}

 
void loop(void)
{
 server.handleClient();
 
 delay(500); 

 float temperatur = getTemperatur();
 if (merketemperatur!=temperatur) {
 zeigeTemperatur(temperatur);
 merketemperatur=temperatur;
 }
}

Auch hier noch mal kurz die Erläuterung der Funktion:

Der Server ist quasi ständig empfangsbereit und erhält seine Daten durch den genannten URL-Aufruf. Sobald der Außensensor die Temperatur übermittelt hat, wird diese auf dem angeschlossenen Farbdisplay angezeigt. Zwischendurch misst der Server auch noch die Temperatur am direkt angeschlossenen Sensor und gibt auch diese auf dem Display aus sobald sich ein Wert verändert hat.

Und zu guter letzt haben wir den Server gleich so programmiert, dass bei einem URL-Aufruf auch die Temperaturwerte als Text zurückgegeben werden. Das hat den Vorteil, dass Ihr die URL eures Servers auch direkt im Browser eingeben könnt, beide Temperaturwerte werden euch dann im Browser aufgelistet!
Dabei spielt es keine Rolle ob Ihr die URL des Unterverzeichnisses oder des Root Verzeichnis aufruft.

Beispiel:

http://192.168.2.75/sensor/temperatur/

oder

http://192.168.2.75

Die Ausgabe ist stets:

*** Ueberwachungs Server - Beispiel von www.mikrocontroller-elektronik.de ***
 Temperatur Innen : 19.12
 Temperatur Aussen: 20.00

Auf das „ß“ müssen wir auf dem Display verzichten, da dieses nicht im Zeichensatz der Lib vorhanden ist.
Ihr seht, unser Server leistet derzeit schon einiges, trotz des kurzen Sketches werden viele Möglichkeiten aufgezeigt. Wenn Ihr den Code ein wenig studiert, werdet Ihr erkennen wie einfach sich viele Dinge mit dem NodeMCU-Board umsetzen lassen. Die beiden Sketches können daher ein gutes Grundgerüst für viele Aufgaben darstellen.

Warum nicht NodeMCU als WLAN Access Point definieren?

Vielleicht fragt sich jetzt der ein oder andere, warum haben wir den Server nicht als Access Point konfiguriert. Er würde dann ja ein eigenes WLAN-Netz aufmachen und müsste sich nicht mit dem hauseigenen WLAN-Netz verbinden. Ähnlich wie es heute Kameras machen. In der Tat wäre das genauso leicht machbar gewesen, jedoch müsste dann immer der Server im Innenbereich in Reichweite des Außensensors liegen. Bei größerer Entfernung und dicken Mauern könnte es dann manchmal schwierig werden. Wenn man schon ein gutes hauseigenes WLAN-Netz hat, vielleicht eines das sogar durch einige Repeater sehr gut im Haus und Garten empfangbar ist, dann ist es natürlich vorteilhafter dieses zu nutzen. Die Reichweite eines NodeMCU-Boards muss dann ja nur bis zum Router oder nächsten Repeater reichen.

Natürlich könnte man auch Repeater für ein NodeMCU-Netzwerk einsetzen, man könnte sogar NodeMCU-Boards selbst als Repeater programmieren. Aber das ist wieder ein anderes Thema und würde nun wirklich diesen Beitrag sprengen.

Fertig – Client und Server

Ich hoffe ich konnte ich Euch die Programmierung des NodeMCU-Boards mit diesem kleinen Tutorial ein wenig näher bringen und vielleicht die ersten Erfolge bescheren. Weitere Anregungen oder Projekte findet Ihr auf den verlinkten Seiten und den unten gezeigten Buchtiteln.

Man könnte auch unser Beispielprojekt noch erheblich ausbauen, zum Beispiel könnte man auf dem Server auch noch andere Angaben von anderen Sensoren ausgeben, wenn man die Schrift etwas kleiner wählt hat man da noch viel Platz. Man könnte zum Beispiel auch eine Meldung ausgeben wenn Post im Briefkasten liegt. Falls Ihr irgend was Interessantes umgesetzt habt, könnt Ihr es gerne in einem Kommentar angeben oder auch als Foto schicken.

Also viel Spaß beim Basteln!

Empehlenswerter Buchtitel für Leser die NodeMCU oder ESP8266 per C programmieren wollen

Das ESP8266-Projektbuch. Heimautomation mit dem WLAN-Chip*

Martin Mohr (Autor)

19,71 EUR

Letzte Aktualisierung am 2024-11-21 / * Affiliate Links 

Empehlenswerter Buchtitel für Leser die NodeMCU oder ESP8266 per Lua programmieren wollen

Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer*

Artikelname: Das ESP8266 Praxisbuch: Mit NodeMCU und ESPlorer; Produkttyp: ABIS BOOK; Farbe: Silber

139,99 EUR

Letzte Aktualisierung am 2024-11-21 / * Affiliate Links 

Links zum Thema

• ESP12E-Tutorial und ESP-Adapter-Projekt
• NodeMCU – Projektseite (Englisch) – Beschäftigt sich vorwiegend mit Lua als Programmiersprache
• Flash-Tool mit integrierter Firmware
• Datenblatt zum USB-Chip CP2102
• Hersteller der ESP8266-Serie spressif.com
• Schaltplan zum NodeMCU-Board
• Schaltplan eines ESP12 Moduls (Reverse engineered)
• ESP12E-Pinbelegung (PDF)
• ESP12E Programmierung über seriellen Adapter
• Neues deutsches Forum zum NodeMCU-Board und der ESP8266-, ESP32-Serie
• Englisches Forum zum ESP8266 / NodeMCU
• Tipps und Hinweise zur Arduino ESP8266 / ESP12E Programmierung und Lib
• Energiesparende Alternative zu WLAN = RFM12B
• Bezugsquelle für NodeMCU Amazon*  / Ebay*
• Bezugsquelle für ESP8266 Modul ESP12-E Amazon* / Ebay* 
• Deutsche Bücher zu NodeMCU und ESP8266
• Farbcode Picker für individuelle Farben auf dem gezeigten SPI-Display
• Tipps/Beispiele zu den Befehlen der verwendeten Arduino Adafruit GFX Library

Links vorwiegend für LUA-Programmierer

• NodeMCU – Dokumentation (englisch)
• NodeMCU / Lua tutorial (englisch)
• Offizielle Lua Hompage (englisch)
• Deutsche Übersetzung der Lua Doku
• Buch Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer (deutsch)*  / Review auch hier
• ESPlorer -Beliebte Entwicklungsumgebung für Lua Programmierer
• MSXFAQ – Blog

Weitere Hinweise

Das Projekt unterliegt einer CC-Lizenz - Lizenzhinweis (zum Aufklappen anklicken)

Um ihnen weitgehende Möglichkeiten zum Nutzen der Schaltung einzuräumen, wurde dieses Projekt jetzt unter die CC-Lizenz gestellt. Sie haben So die Möglichkeit die Schaltung beliebig zu verändern oder weiterzugeben. Lediglich die kommerzielle Weitergaben ist nur mit Genehmigung möglich! Genauere Hinweise finden Sie im Lizenztext. Bei einer Veröffentlichung oder Weitergabe ist nachfolgender Text sichtbar zu übernehmen:

---

Falls Dir der Beitrag gefallen oder geholfen hat kannst Du dem Autor aber gerne durch eine kleine Spende Danke sagen!

Projekt (Schaltung & Projektdateien) von Frank ist lizenziert unter einer Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 4.0 International Lizenz. Über diese Lizenz hinausgehende Erlaubnisse können Sie unter https://www.mikrocontroller-elektronik.de/ erhalten. Lizenziert wurde das Projekt von: www.Roboternetz.de & www.Mikrocontroller-Elektronik.de  -  Autor/User Frank Dieser Name und diese Webseiten sind bei der Weitergabe stets deutlich sichtbar zu nennen!

---