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.

ESP8266-Modul-Varianten

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?

nodemcu

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:

NodeMCU-Schaltplan-USB

Schaltplan des USB-Teils auf dem NodeMCU-Board

Ein NodeMCU von unten gesehen

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.

NodeMCU-esp8266-esp12e-hand

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

esp12e-wlan-modul-pinbelegung

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

Pinbelegung eines NodeMCU-Boards (hier Version 2)

NodeMCU Pinbelegung

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

 

ESP12E-Pinbelegung

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.

NodeMCU-Taster-Schaltplan

 

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
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
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-12-07 / * Affiliate Links 

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

NodeMCU-Arduino-IDE-Eingepackt

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.

NodeMCU-Arduino-IDE-TFT-Finger

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

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:

NodeMCU-Arduino-IDE-Stepp2

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.

NodeMCU-Arduino-IDE-Stepp3

 

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.

NodeMCU-Arduino-IDE-Stepp3b

Achtung, manchmal macht die Version 2.3 Probleme

Achtung Fallstrick:  in der Regel sollte man jetzt die neueste Version auswählen und dann auf den Button Installieren klicken. Danach werden alle notwendigen Dateien zur Programmierung in euer Windows Verzeichnis C:\Users\DeinBenutzername\AppData\Local\Arduino15\packages\esp8266 installiert.
Auch ich habe das anfangs so gemacht, musste aber später immer wieder feststellen, dass mein erworbenes NodeMCU-Board bei der Ausführung von Programmen aus unerklärlichen Gründen oft einen RESET durchführte.
Dieses Problem war weg, nachdem ich statt der Version 2.3.0 das Paket 2.2.0 installierte. Um Euch den Frust zu ersparen, empfehle ich Euch daher auch 2.2.0 zu nutzen. Ihr könnt es natürlich auch mit der neusten Version probieren, solltet aber die Sache  im Hinterkopf behalten. Macht euer Programm/Sketch nicht das was es soll und erscheint über die serielle Schnittstelle oft eine WDT-Reset Fehlermeldung, dann deinstalliert die 2.3.0 wieder über die Boardverwaltung und versucht es mal mit Version 2.2.0.

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.

NodeMCU-Arduino-IDE-Uebertragen

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.

Achtung Fallstrick:  Eine Antiviren-Software (wie z.B. Avira) kann die Compilierung von Programmen dermaßen stark verlängern, dass die Arbeit mit der IDE keinen Spaß mehr macht.  Sollte das bei Euch der Fall sein, dann könnt Ihr den Echtzeitschutz für einen Pfad abschalten. Tragt dazu einfach den Pfad der ESP-Boardverwaltung (gewöhnlich C:\Users\DeinBenutzername\AppData\Local\Arduino15\packages\esp8266) als Ausnahme in eurem Antiviren-Programm ein, das beschleunigt die Sache um ein Vielfaches.

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);
 }

Achtung Fallstrick: Habt Ihr alle Schritte genau befolgt und dennoch macht das Programm nach der Übertragung nicht das was es soll, so kann dies eventuell an der Konfigurierung des Moduls liegen. in dem Fall ist es am einfachsten, wenn Ihr noch mal die Standard-Firmware und Konfigurierung mit einem speziellen Flash-Tool aufspielt. Keine Sorge, das geht ganz einfach!

 

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.

NodeMCU-Flash-Tool-Lua

 

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:

 

Mit der NodeMCU-Programmierung loslegen

Mit NodeMCU_Board Temperatursensor DS 18B20 auslesen

Digitaler Temperatursensor DS18S20

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:

Zur Erinnerung, eine neue Library liegt meistens als ZIP-Datei vor, sie kann über den Menüpunkt Sketch / Bibliothek einbinden / ZIP Bibliothek hinzufügen über die IDE installiert werden! Sie wird dann übrigens unter Windows im Verzeichnis C:\Users\DeinBenutzername\Documents\Arduino\libraries abgelegt. Man könnte sie auch selbst dort entpacken. Unbedingt darauf achten, dass dort beim Entpacken auch die richtige Ordnerstruktur erhalten bleibt, wenn im Unterordner der Library das Verzeichnis examples zu finden ist, dann ist es korrekt!
Mein Verzeichnis sieht beispielsweise so aus:

Arduino-Lib-Verzeichnis

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.

Arduino-Serieller-Monitor

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);

NodeMCU-Arduino-IDE-temperaturausgaben

Hier die Schaltung:

NodeMCU-Arduino-IDE-DS18B20-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:

NodeMCU-Arduino-IDE-TFT-rueckseite

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:

 

NodeMCU-Arduino-IDE-TFT-temperaturanzeige1

 

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

NodeMCU Qvga-Display DS18B20 Schaltung

 

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

NodeMCU-Aussentemperatur-Schaltung

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

Achtung: Damit das Modul auch nach 15 Minuten automatisch geweckt wird, müsst Ihr unbedingt bei der Schaltung den Pin Reset und D0 (GPIO16) mit einem Draht brücken, ansonsten würde das Board nicht mehr erwachen. Diese Brücke kann manchmal beim Programmieren des Moduls Probleme bereiten, daher am besten trennen, wenn Ihr ein Programm auf das NodeMCU-Board übertragt.

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.

NodeMCU-Sever-mit-Innentemperaturmessung-Schaltung

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.

NodeMCU-Fertige-Projekt-mit-aussen-und-innentemperaturmessung

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

Letzte Aktualisierung am 2024-12-07 / * Affiliate Links 

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

Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer
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-12-07 / * Affiliate Links 

 

Links zum Thema

Links vorwiegend für LUA-Programmierer

 

 

Weitere Hinweise

Vor dem Aufbau bitte nachfolgende Hinweise lesen:
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:
cc_logo310

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!
Achtung: Es kann keinerlei Garantie für die Fehlerfreiheit der Schaltung oder anderer Projektdateien übernommen werden! Der Nachbau und Betrieb geschieht auf eigene Gefahr! Jegliche Haftung für Schäden oder Verletzungen wird ausgeschlossen! Schadensersatzansprüche, gleich aus welchem Rechtsgrund, sind ausgeschlossen.
Sicherheitshinweise und Haftungsausschluss (zum Aufklappen anklicken)
Dieses Projekt dient vornehmlich für Lehrzwecke und zum Experimentieren. Für den Aufbau sollten ausreichend Elektronik Grundkenntnisse und Kenntnisse bezüglich der Sicherheit (Experimentieren mit Strom und Handhabung gängiger Werkzeuge wie Lötkolben etc.) vorhanden sein. Unter dem Menüpunkt Buchvorstellungen als auch auf der Seite RN-Wissen.de empfehle ich diesbezüglich noch interessante Literatur mit der man sich dies erarbeiten kann. Für Fragen bezüglich Elektronik und Mikrocontroller empfehle ich das Forum: Roboternetz.de Sicherheitshinweise und Haftungsausschluss

71 Kommentare zu “NodeMCU und ESP8266 – Einstieg in die Programmierung”

  1. Christian sagt:

    Hallo Frank,

    vielen Dank für deinen sehr hilfreichen Beitrag. Ich fange gerade erst mit NodeMCU an und bekomme leider schon bei deinem ersten Beispiel kein blinkendes Licht.

    Ich nutze:
    NodeMCU 12E (geflasht mit dem Tool das du benannt hast)
    Arduino IDE 1.8.1
    ESP 2.2.0

    Die Übertragung funktioniert, die LED blinkt bei der Übertragung, aber wenn die Übertragung fertig ist, passiert leider einfach gar nichts…

    Hast du eine Idee was das Problem sein könnte?

    Danke und Grüße,
    Christian

    1. Frank sagt:

      Hi
      Eigentlich sollte das problemlos klappen, ich habe es auf drei NodeMCU Boards ausprobiert. Was hast du für eine Variante, wo gekauft? Eventuell gibt es da die LED nicht drauf, beachte das die rote LED blinken sollte! Notfalls mal nachmessen oder LED mit Widerstand an den Port hängen. Auch mal den seriellen Monitor anwerfen und schauen ob das Board irgend welche Fehlermeldungen ausgibt. Bei Fehlern wird oft ein SoftReset ausgeführt, das wird aber über die serielle Schnittstelle gewöhnlich gemeldet.
      Gruß Frank

      1. Peter sagt:

        Hallo,
        bei den neueren Versionen des Boards (bei meiner v3) hängt die LED an GPIO2.
        Mit #define LED_BUILTIN 2 blinkt es dann auch.

        Gruß
        p.

    2. Michael sagt:

      Das gleiche Problem hatte ich auch. Die Lösung war einfach: Auf meinem Board gibt es gar keine rote LED 😉 Aber wenn ich den Pin auf D4 ändere, blinkt die blaue LED vom Funk-Modul. Von daher alles okay.

      Ich verwende dieses Modul: “NodeMCU V3 Module ESP8266 ESP-12E mit CH340 Chip*

  2. Sascha sagt:

    Hallo.
    Zunächst Danke für den Super Beitrag.

    Ich habe seit 2 Tagen mein erstes NodeMCU Board (link siehe unten) und verschiedene der Beispiele die dabei sind ausprobiert und leicht modifiziert (Arduino IDE 1.8.1, NodeMCU-Board Version 2.2.0/2.3.0, Firmware geflasht). Habe ein wenig Erfahrung mit dem Arduino an sich, bin als kein kompletter Neuling 😉 Leider stürzt das Board ständig ab. Es ist also auch kein Reset, da das Programm nicht neu startet. Der Neustart erfolgt erst nachdem ich den Resetknopf betätigt habe. Spannungsstabilisiert ist das Board ja soweit ich weiss. Ich bin langsam echt ratlos. Hat jemand eine Idee, was das Problem sein könnte.

    Es ist auch egal, ob das Board direkt am Rechner hängt, oder an einem Akku-Pack oder anderen USB-Netzteil.
    Wäre schön, wenn jemand noch eine Idee hätte.

    LG und Danke,
    Sascha

    hier noch der Link zum Board …

    http://amzn.to/2k3oI1f

    1. Frank sagt:

      Einen Restet vom Board kann man nicht unbedingt daran erkennen das das Programm nicht ausgeführt wird. Als ich die Lib 2.3.0 genommen habe, da hatte ich die Resets so schnell hintereinander, das das Programm gar nicht richtig zur Ausführung kam. Also am besten beobachten ob es irgend etwas über die serielle Ausgabe meldet, auch wenn es tot wirkt. Oft bekommt man da Hinweis. Ansonsten kenne ich bislang nur die Problemfälle, die ich im Beitrag schon genannt habe. Mal ein Elko oder Akkupack als Stromversorgung zu nutzen ist sicher nicht verkehrt, man muss sich ja an das Problem herantasten. Allerdings habe ich inzwischen festgestellt das es auch ohne zusätzlichen Elko in der Regel stabil läuft, allerdings nutze ich ein wenig anderes Modus (wie du im Artikel siehst).

  3. Tobias sagt:

    Hey Frank!
    Beste Einführung die ich bisher im Netz gefunden habe!!! Sehr gute Arbeit!!!

    Habe auch gleich mal eine Frage:
    Nutze das NodeMCU esp12e mit dem Boardpaket 2.2.0 wie von dir empfohlen um eine Uhrzeit dezimal auf einen Adafruit Neopixel Strip zu bringen (60 Neopixel). Alles wird von einem Schaltnetzteil (output 5V, 4 A) versorgt. Musste dazu die Diode zwischen Vin und USBVDD überbrücken. Bevor ich das tat, lief das Board nur über USB.
    Nun habe ich folgendes Problem: Irgendwann (zufällig) hört das Programm auf zu laufen. Die loop stoppt quasi möchte man meinen mit der Besonderheit, dass immer wenn ich einen neuen URL request (über die ich zb die Farbe einstelle) versende, der Strip wieder reagiert. Die aktuelle Uhrzeit wird angezeigt und bleibt dann aber wieder stehen. Wie gesagt – Programm funktioniert – hängt nur nach einer Zeit bzw. wenn ich URL Anfragen über die RouterIP –> Portweiterleitung mache. URL Anfragen über lokale IP läuft besser.
    Und wenn ich das Ding anmache und nichts per URL request eingebe hängt er sich nach einer Zeit von 10mins bis 2h auf.
    Delay(1) habe ich überall eingebaut und auch sonst alles probiert bis auf das flashen mit LUA (habe einen MAC….).
    Vielleicht hast Du ja eine Idee woran es liegen könnte.
    Liebe Grüße!!! Tobias

    1. Tobias sagt:

      Ich habe die Lösung des Problems gefunden. Grund für die Aufhänger waren URL-Requests die nicht verarbeitet werden konnten weil im Programmcode nicht hinterlegt und eine Eigenart die z.B. Firefox hat: Wenn man eine Seite auf hat und den Mauszeiger auf einen Button führt OHNE ihn anzuklicken sendet der Browser etwas (in meinem Fall an das NodeMCU, was einen Client erkennt, aber keine Daten empfängt). Deswegen habe ich eine Timeout Schleife für solche Fälle implementiert und nun läuft alles einwandfrei!!!!
      Hier der Code für Leute mit ähnlichen Problemen:


      WiFiClient client = server.available();

      if (!client) {
      return;
      }

      Serial.println("new client");
      long actualmillis = millis();
      while (!client.available() && (millis() - actualmillis 1000) {
      Serial.println("Error: failed to read request");
      client.flush();
      client.println("HTTP/1.1 404 WTF Favicon !!\r\n");
      client.stop();
      return;
      }

      1. Frank sagt:

        Danke für den hilfreichen Hinweis und natürlich auch das Lob.

      2. Thomas sagt:

        Moin Frank, Moin Tobias,
        Vielen Dank euch beiden für die super guten Dokumentationen! Ich hatte genau das gleiche Problem wie Tobias…

        Webserver Beispelsketch hochgeladen, funktionierte einige Zeit, dann nach spätestens einer Stunde lief nichts mehr. Der serielle Monitor brachte mich auch nicht weiter. Nur Reset Button hilft. Dann FW geflasht. Bibliotheken hoch und runter gerüstet. Frustriert einen weiteren ESP bestellt, um festzustellen dass hier das gleiche Problem vorlag 🙁

        Weiter Dr. G durchforstet und dann diese TOLLE SEITE gefunden! Den Code von Tobias dazwischengefriemelt, zwischen “actualmillis 1000” noch ein> Zeichen gesetzt, und nun läuft mein ESP schon gut 3 Stunden 😀 😀

        Daher nochmal: DANKE!

  4. Sector sagt:

    Die onboard LED des NodeMCU spricht man mit D4 oder Pin 2 an.
    Gruß, Sector

    1. Frank sagt:

      Das stimmt nicht so ganz, D4 ist die interne LED des ESP12E Moduls (siehe Tabelle im Beitrag). Die zusätzliche LED des NodeMCU Boards spricht man wie in unserem Beispiel mit D0 an.
      Gruß
      Frank

  5. Tobias sagt:

    Hallo Frank,
    erstmal vielen Dank für das tolle Tutorial. Es hat mir den Einstieg sehr erleichtert.

    Leider wacht mein Board nach dem Befehl

    ESP.deepSleep( 15*60000000)

    nicht mehr auf, obwohl ich Reset und D0 (GPIO16) verbunden habe.
    Lässt sich das Board noch irgendwie wiederbeleben?

    Viele Grüße
    Tobi

    1. Frank sagt:

      Wenn Du Reset und GPIO16 verbunden hast, dann muss das Board in jedem Fall nach 15 Minuten aufwachen wenn Du den Befehl ESP.deepSleep( 15*60000000); eingibst. Nach 15 Minuten führt dann GPIO16 ein Reset aus. Natürlich kannst du das Board auch jederzeit vorher aufwecken indem Du selbst Reset am NodeMCU Board drückst (also Pin RESET kurz auf GND legst). Achte darauf das Du beim testen des DeepSleep eventuell das USB Kabel abziehst, manchmal kann der den Reset Pin blockieren. Auch darf der Reset oder GPIO16 PIN natürlich nicht irgendwie fest auf einen Pegel gezogen werden. Wenn das alles nicht hilft, das muss noch was am Programm nicht stimmen, notfalls auch mal im Forum deinen Code / Schaltung posten und fragen.

      1. Tobias sagt:

        Hallo Frank,
        vielen Dank für die schnelle Antwort.

        Inzwischen habe ich eine Lösung gefunden.

        Zwar ließen weder das Drücken des Resetknopfes noch das Abziehen des USB-Kabels das Board erwachen und das einfache Hochladen von Sketchen blieb unmöglich.

        Der Sketch, welcher den „Hänger“ verursacht hatte, ließ sich aber schließlich dadurch überschreiben, dass ich während des Hochladens eines neuen Sketches die Flash-Taste des Boards gedrückt hielt.

        Viele Grüße
        Tobi

        1. Frank sagt:

          Merkwürdiges Verhalten.Ich denke nicht das er geschlafen hat, vielleicht war einfach Programm nicht richtig übertragen oder fehlerhaft. Aber Hauptsache es geht wieder.

  6. Joachim Seeger sagt:

    Hallo Frank
    in der Zeichnung zum ESP 12 Modul sind die folgenden pins mit

    19 – D2 – GPIO 4 – SDA
    20 – D1 – GPIO 5 – SCL

    bezeichnet.
    In deiner Schaltung verwendest du es als D0 bzw. D/C.
    Ist damit der I2C Ausgang belegt oder kann man per Software den Ausgang umschalten?
    Ist ein gleichzeitiger Betrieb von I2C und SPI möglich?
    achim

    1. Frank sagt:

      Die Standard-Belegung des I2c-Bus kann man mit dem Befehl Wire.begin ändern. Ich bringe demnächst noch mal ein kleines Beispiel mit einem Feuchtesensor. SPI könntest Du natürlich neben I2C auch nutzen, solange die freien Ports nicht ausgehen.

  7. Joachim Seeger sagt:

    Hallo Frank
    Dein Artikel beschreib sehr viel. Auch das mit dem I2C Bus ist soweit klar. Im Netz gibt es ca. 100 verschiedene Pinbelegungen. Alle gehen im Grunde auf das selbe Bild zurück. Danach stehen die Pins D0 bis D10 zur “freien Verfügung, zuzüglich A0 zur Messung von ADC. Einige Pins sind zur Programmierung reserviert. Einige Pins sind für den SPI Bus genutzt.
    Welche Pins kann man für was verwenden? An welche Pins kann man LED oder Taster anhängen? Welche müssen frei bleiben? Welche sind begrenzt nutzbar und für was?
    Leider sind die Angaben im Netz alle sehr kurz geraten. Vielleicht kannst du zu einer Aufklärung beitragen.
    achim

    1. Frank sagt:

      Nun ja im Prinzip steht ja im Artikel welche Pin´s belegt sind. Zum Beispiel die Pins die intern für Flash genutzt werden, kann man normalerweise auch nicht nutzen. Recht unbesorgt können eigentlich nur die in meinem Datenblatt bezeichneten Pins (gelb gekennzeichnet) D0 bis D10 sowie ADC genutzt werden, alle anderen sind gewöhnlich nicht verwendbar. Aber auch die Pin´s von D0 bis D10 werden natürlich für einige andere Zwecke genutzt, beispielsweise RX / TX zur Programmierung oder für LED. Einige davon müssen auch nach dem RESET einen bestimmten Zustand aufweisen, könnten aber auch danach zum Abfragen einer Taste genutzt werden. Also es kommt immer drauf an was du wie nutzt. Du könntest zum Beispiel die Flash-Taste (D3/GPIO0) auch nutzen um einen Taster abzufragen der nach GND schaltet. Beim Nodemcu kannst du also den vorhandenen Taster für Testzwecke umprogrammieren. Wenn du nur ein Notruftaster bauen willst, dann könntest du selbst die RESET-Taste am NodeMCU-Board oder an meinem ESP-Adapter dafür nutzen, indem nach einem Reset einfach ein Notruf gesendet wird. Also bei meinem Display-Beispiel Server habe ich schon ziemlich alle verfügbaren Ports verwendet wenn ich mich richtig erinnere.

  8. Falk sagt:

    Hallo Frank,

    dein tolles Tutorial hat mir den Einstieg deutlich vereinfacht!
    Vielen Dank dafür!

    Gruß Falk

  9. Dieter Gerblinger sagt:

    Hallo Frank,
    ich bin am verzweifeln:-(
    Deine genauen Ausführungen sind überaus hilfreich für “Neueinsteiger” wie ich einer bin.
    Immer wieder habe ich rumprobiert, bekomme aber keine Verbindung zwischen den beiden ESPs.
    Folgende Meldungen erscheinen:
    …..
    WiFi Verbindung aufgebaut
    Eigene IP des ESP-Modul: 192.168.178.22
    Temperatur: 20.7
    Verbindungsaufbau zu Server 192.168.178.24
    Folgende URL wird aufgerufen: 192.168.178.24/sensor/temperatur/?pw=20.7
    Timeout!
    Uebergabe klappt nicht, ich versuche es spaeter noch mal!

    Hättest du dazu vielleicht einen Tip??
    Schon mal vielen Dank im Voraus.
    Dieter

    1. Frank sagt:

      Ich vermute das bei dir mit der IP-Konfiguration etwas nicht stimmt. Du solltest Dich im WLAn-Router (Fritzbox) einloggen und prüfen ob die korrekten IP´s vergeben wurden. Wenn Du beim NodeMCU Server (also Display-Server) die IP wie ich konfiguriere, also mit der Anweisung

      IPAddress ip(192,168,2,75); //Feste IP des neuen Servers, frei wählbar

      dann ist es wichtig das dein Router im gleichen Netz ist. Das bedeutet die ersten drei Ziffern der IP müssen übereinstimmen “192,168,2,…”.
      Bei den meisten Heimnetzen wird aber “192,168,1,…” verwendet. In so einem Fall musst du auch dem Displayserver eine IP geben die so anfängt.
      Also beispielsweise mit dieser Codezeile im Displayserver:

      IPAddress ip(192,168,1,75); //Feste IP des neuen Servers, frei wählbar

      Die aufzurufende IP muss dann natürlich auch beim Sensor ESP angepasst werden.

  10. Stefan sagt:

    Du hast geschrieben, dass das ESP Modul im Deep Sleep nur 0,5µA aufnimmt. Ich schätze, dass diese Angabe einem alten Datenblatt entstammt und dass du es nicht überprüft hast.

    Man sollte dazu wissen, dass der Chip-Hersteller eine Menge maßlose übertreibungen in seine Dokumente geschrieben hat. Die 0,5µA sin völlig falsch. Im Aktuellen Datenblatt steht 25µA bei 2,5V und ohne Berücksichtigung des Flash Speichers. Und diese Angabe ist richtig, ich hab’s nachgemessen.

    1. Frank sagt:

      Die Angabe stammt glaube aus einem Fachbuch über die ESP-Serie. Aber ich glaube Du hast durchaus recht, die tatsächliche Stromaufnahme inkl. Flash liegt wohl etwas höher. Allerdings habe ich bei meiner Platine mit ESP-Modul (siehe Beitrag “ESP12E, Einstieg mit dem ESP8266 Modul“) etwas unter 20 µA gemessen, inkl. Spannungsregler. Kann natürlich am Fehler beim Messgerät liegen.

  11. Pascal sagt:

    Hallo Frank

    Danke für deinen tollen praktische Anleitung. Ich konnte die Verbindung soweit funktionsfähig aufsetzten. Nun möchte ich neben der Temperatur auch die Feuchtigkeit übertragen. Was im moment noch nicht klappt. Folgendes rufe ich vom Client auf:
    Folgende URL wird aufgerufen: 192.168.178.45/sensor/temperatur/?pw=passwortxyz&idnr=1&wert=25.0
    Folgende URL wird aufgerufen: 192.168.178.45/sensor/humidity/?pw=passwortxyz&idnr=1&wert=63.0

    Beim Server habe ich zusätzlich eingefügt:
    server.on(“/sensor/humidity/”, handleHum);
    mit der dazugehörigen Funktion.

    Für die aussenHumidity gibt es mir beim Server 0 zurück.

    Hättest du mir einen Tipp?

    1. Frank sagt:

      Hallo, klingt eigentlich richtig wie Du es gemacht hast. Irgendwo scheinst Du aber noch kleinen Fehler im Code zu haben. Es gibt natürlich verschiedene Möglichkeiten wie man es machen kann. Bei meinem Projekt lasse ich inzwischen auch Außentemperatur und Feuchte sowie Batteriezustand anzeigen. Ist aber schon ne Weile her wo ich es fertig gemacht habe, läuft bei mir seit Monaten recht stabil. Ich habe den Code noch mal komplett geändert und übertrage jetzt Temperatur, Feuchtigkeit,Batteriespannung und Standaort des Sensors mit folgender Url:
      http://192.168.2.75/sensor/temperatur/?pw=passwortxyz&idnr=2&wert=20&location=Solarlampe&feuchte=31&batt=5

      Natürlich muss dann auch der andere Code angepasst werden. Mein Code ist ziemlich individuell auf mich zugeschnitten und eigentlich noch nicht ganz fertig. Ich wollte irgendwann bei mir die Reaktion auf Taste verbessern, die ist in meinem neuen Code noch etwas träge. Falls es interessiert, kann ich ihn ja irgendwann mal etwas lesbarer machen und noch zum Download auf die Seite bringen.

      1. Andreas Schweiger sagt:

        tolles. Projekt hat auf anhieb geklappt.
        die Erweiterungen die du gemacht hast sind genau das was ich suche, gibt es eine Möglichkeit deinen Code an Beta-Tester zu nutzen?
        Oder hast du schon einen Termin in Aussicht bis wann du den evtl. Online stellst?

        Danke im voraus.

        gruß
        Andreas

        1. Frank sagt:

          Dei aktuelle Version die ich nutze läuft soweit schon stabil, aber sie ist sehr individuell auf mich zugeschnitten. Momentan fehlt mir etwas die Zeit um das für den Blog bereitzustellen. Aber sobald ich mich wieder damit beschäftige, werde ich es gerne noch einstellen. Am besten Newsletter bestellen, dann verpasst Du es nicht.

  12. Fere Blanck sagt:

    Danke!

  13. Andy sagt:

    Hallo
    Vielen Dank für die sehr ausführlichen Erklärungen und Sketche. Als Neueinsteiger wie ich ist das wirklich sehr gut beschrieben und endlich mal was in deutsch.
    Ich habe mir die Sketche füe die Server-Client Kommunikation heruntergeladen und in soweit abgeänder (Server-Sketch), dass der Server im AP-Modus laufen soll und nicht über einen Router. Dazu habe ich die folgenden Zeilen im Server-Sketch unter voie_setup eingefügt:

    WiFi.begin();
    WiFi.mode(WIFI_AP_STA);
    WiFi.softAPConfig(ip, gateway, subnet);
    WiFi.softAP(ssid, pass);

    Mein Problem ist jetzt, das der Client sich einmal verbindet und einmal die Temperatur sendet und dann kann sich der Client nicht mehr verbinden.

    Verbindungsaufbau zu Server 192.168.4.1
    Verbindungsaufbau nicht moeglich!!!
    Klappt nicht, ich versuche es spaeter noch mal!

    An was kann das liegen, wäre schön, wenn mir da jemand helfen könnte.
    Danke schon mal im voraus.

    MfG
    Andy

  14. Christian sagt:

    Hallo
    habe ein ESP8266 V3 dazu habe ich diese Funksender/Empfänger* im Arduino habe ich das rc switch script hochgeladen jedoch bekomme ich im SeriellenMonitor beim schalten von Funksteckdosen nichts angezeigt .
    Ich komme nicht mehr weiter
    MFG Chris

    1. Frank sagt:

      Kann ich Dir nichts sagen, kenne diese Funkmodule nicht näher.

  15. Richard Haldemann sagt:

    Hallo
    Habe gerade Probleme das Beispiel mit Tempsensor durchzuspielen.
    Erstes Beispiel mit blinkendem Led geht.
    Also sollte die Installation richtig sein.
    Doch schon beim zweiten Beispiel kommt folgende Fehlermeldung :

    Multiple libraries were found for “DallasTemperature.h”
    Used: /home/richard/Arduino/libraries/DallasTemperature
    Not used: /home/richard/Arduino/libraries/Arduino-Temperature-Control-Library-master
    /home/richard/Arduino/libraries/arduino-base64-master/Base64.cpp:2:26: fatal error: avr/pgmspace.h: No such file or directory
    #include
    ^
    compilation terminated.
    exit status 1
    Error compiling for board NodeMCU 1.0 (ESP-12E Module).
    Komme nicht auf den möglichen Fehler. Wer kann mir helfen?

    1. Frank sagt:

      Sieht so aus als nimmst Du die normale DallasTemperature-Lib. Das Problem ist im beitrag ja beschrieben, du musst die andere DallasTemperature-Lib nehmen. Links und Tipps dazu oben im Beitrag.

  16. Peter sagt:

    Hallo!
    Vielen Dank für die schöne Einführung. Hat alles sehr gut geklappt. Ich finde das ist auch mal ein richtig schönes Anwendungsbeispiel. auch wenn ich mit dem Arduino Kram noch nicht so klar komme.
    Ich kann die Daten zu dem Server schicken und er zeigt die Daten im Browser an.
    Was ich nun versuche ist, den Client mit dem original AT Befehlen dazu zu bewegen, genau die selben Daten an den Server zu schicken. Beispile für einen TCP Verbindungsaufbau finde ich viele, aber mein Problem ist, dass etwa eine halbe Sekunde nach dem OK schon die CLOSED Meldung kommt. das sieht in Auszügen so aus:
    AT+CIPSTART=”TCP”,”192.168.2.230″,80
    CONNECT

    OK
    CLOSED

    Wie macht man es richtig?
    Gruß Peter

    1. Frank sagt:

      Zu den AT-Befehlen kann ich Dir nichts mehr sagen, die habe ich schon lange nicht mehr genutzt.

  17. Michael sagt:

    Hallo Frank,
    eine super Einführung zu diesem Chip.
    Zu “NodeMCU ganz neu mit Lua-Firmware flashen” habe ich eine Frage.
    Ich habe zwei esp8266 esp-01 bei denen das Programm (blink) über die Arduino IDE zwar fehlerfrei hochgeladen wird, allerdings führt der Chip hinterher das programm nicht aus. Das problem habe ich mit beiden chips.
    Kann ich diese genauso mit der Firmware flashen? Wenn Ja, wo bekomme ich das passende Fashtool und die Firmware als Download. Ich suche schon seit einer Woche im Netz nach einer Problemlösung dein Beitrag ist der erste, der darauf hinweist das die Konfiguration der Module das problem verursachen können.
    Gruß Michael

    1. Frank sagt:

      Mit dem ESP-01 habe ich mich nicht näher beschäftigt, dazu kann ich dir nicht viel sagen. Die Firmware vom ESP12E geht da jedenfalls nicht.

    2. Stefan sagt:

      Wenn du mit der Arduino IDE einen Sketch in den Chip überträgst, spielt es keine Rolle, welche Firmware da vorher drin war. Sie wird dabei komplett ersetzt.

      Die ESP-01 Modelle werden teilweise mit nur 512k Byte Speicher verkauft. Versuche mal, in der IDE das “generic ESP82666” Board einzustellen und dann als Speicher 512k 80Mhz QIO.

      Falls du außerhalb der IDE flashen willst, empfehle ich Dir das Kommandozeilenprogramm esptool.py (du wirst es mit Google finden). Das zickt weniger rum, als die schönen bunten grafischen Programme. Zum Ausführen musst du vorher Python installieren und im Befehlsfenster einmal “pip install pyserial” eingeben, um eine Library für serielle Ports zu instalieren.

  18. Erhard sagt:

    Hallo Frank,
    Ich habe dein Beispiel nachgebaut, es funktioniert wunderbar.
    Vielen Dank.
    ich versuche nun verzweifelt, (Anfänger) eine weiteren Client einzubinden.
    Im Server zeigt jetzt die Arduino IDE folgenden Fehler: zeigeAussenTemperatur’ was not declared in this scope.
    Die Werte beider Clients werden umschichtig auf dem Display angezeigt
    Kannst du helfen?

    Erhard

    1. Frank sagt:

      Scheinbar findet er deine Funktion im Code nicht, irgendwo musst Du da noch Bug drin haben. Sorry mehr kann ich dir da auch nicht sagen.

  19. Stefan sagt:

    Warum hast die Angabe zur Stromaufnahme nicht korrigiert?

    Im Datenblatt des ESP8266EX steht: typisch 20µA bei 2,5V

    Bei 3,3V und mit Flash Chip ist es dann logischerweise noch etwas mehr, so dass sich meine gemessenen 25µA mit der offiziellen Dokumentation decken.

    1. Frank sagt:

      Weil ich es noch nicht nochmals nachgemessen habe, somit kann ich es noch nicht bestätigen. Bei mir ruht derzeit dieses Projekt, da das für mich erst mal abgeschlossen war. Wenn ich wieder mal ran gehe, werde ich es prüfen.

  20. Peter sagt:

    Hallo
    Das ist mal ein toller Breitrag für einen Neuling wie mich.

    Leider sitze ich schon beim 2. bsp. an einem Problem.Die Blinkende LED ging.
    Der DS18b20 leider nicht. Es kommt keine Ausgabe und die LED erlischt nachdem das Programm gestartet ist.
    Während des Programmstarts bekomme ich folgende Ausgabe
    1264, room 16
    tail 0
    chksum ~ld

    Ich habe mal testweise eine ausgabe eingebaut die auch erscheint, aber nur einmal.
    Du schreibst die Temperatur solle alle 2 Sekunden ausgegeben werden.
    Wieso? Wird das Programm nach seinem Ende immer wieder aufgerufen ? Wenn JA müsste ja auch meine Testausgabe alle 2 Sekunden erscheinen. Im Programm selbst kann ich keine Schleife erkennen für eine Wiederholung erkennen.

    Ich habe 10kOhm zwischen 5V und DQ gelegt.
    Habe statt dem D1 auch schon den D3 probiert…….gleiches Ergebnis.
    Ich benutze ein WEMOS D1 Mini

    Vorab danke und grüße
    Peter

    1. Frank sagt:

      Die Loop Funktion wird bei Arduino immer in einer Schleife aufgerufen.

  21. Peter sagt:

    So … bin etwas weiter.

    Er bekommt immer -127 als wert und deshalb kommt er nie aus der do while schleife raus.
    diese -127 bekommt er egal ob der DS18b20 angeschlossen ist oder nicht und auch egal welchen D-PIN ich verwende. Habe auch schon einen anderen DS18B20 verwendet – geht auch nicht.
    Am Raspi funktionieren die DS18B20
    Wie kann man testen ob er die DS18B20 auf 1Wire-Bus überhaupt erkennt ?
    Grüße
    Peter

    1. Frank sagt:

      Schau auch mal in den Beitrag DS18S20

  22. Peter sagt:

    ES GEHT !!
    Ich werde verrückt…..ein Jumperkambel war ohne Durchgang.
    Diese Dinger machen mich noch irre – andauernd habe ich welche die keinen Durchgang haben oder einen extrem hohen widerstand bieten.
    Grüße

  23. Chris sagt:

    Vielen Dank für den großartigen Artikel! Mir hat es sehr geholfen die ersten Gehversuche zu machen! Ich habe die Funktion der LED mit http Request verbunden und eine einfache Android App erstellt um via Button die LED ein- und auszuschalten. Das war dank dieser Beispiele einfach zu realisieren. Danke!

  24. Ulrich Kraus sagt:

    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.
    ….. die Version V3 hat nur noch die kleine blaue LED direkt auf dem Wlan-Modul, die auf dem Nodemcu entfiel ganz. Es kommt hier bei Beschreibungungen immer wieder zu verwechslungen… so ist bei V3 die interne LED auf D4 und nicht D2!!!

  25. Roider Tom sagt:

    Toller Beitrag! Damit konnte ich schon erfolgreich testen mit dem esp8266.

    Ich habe aber einen Fall, den ich bis jetzt nicht gelöst bekomme:
    Wenn ich einen Stromausfall simuliere (d.h. mein Steckernetzteil ziehe, kurz warte und wieder einstecke), dann wird das Programm im esp8266 nicht geladen. (Kann ich recht einfach testen, indem ich versuche, ihn anzupingen). Drücke ich einmal auf Reset, ist der ping gleich im Anschluss wieder da, d.h. dann wird das Programm auch geladen.
    Entferne ich nur die Stromleitung (lasse also das Netzteil eingesteckt) vom Chip, warte kurz und stecke wieder an, funktioniert es wie gewünscht, dass das Programm geladen wird.
    Nur…in der Praxis (bei einem richtigen Stromausfall) habe ich das Problem, dass ich dann auf Reset drücken müsste…das ist natürlich nicht im Sinne des Erfinders. Hättest Du hier einen anderen Vorschlag? Evtl. eine kleine Schaltung o.ä., die z.B. gezielt beim Start diesen Reset auslöst?

    Vielen Dank für jeden Ratschlag…hab schon gegoogelt, aber nicht wirklich was sinnvolles dazu gefunden…

    1. Frank sagt:

      Das ist nicht normal, bei korrekter Pinbelegung wie beschrieben muss Programm auch neu start. Ich ziehe oft Stecker, hatte noch nie Probleme.

  26. Arne sagt:

    Hallo Frank. Vielen Dank für Deine gut gemachte Webseite. Habe alles so gemacht, wie von Dir beschrieben und mein ESP8266 zum Blinken bekommen. Jetzt geht es Schritt für Schritt weiter mit WLan- Anbindung und Display.

  27. Andreas Glowastka sagt:

    Hallo Frank bin auf deiner Seite gelandet, sehr interessant und Sehrgute Beschreibung bin Anfänger und seit drei Monaten dabei habe schon einige Projekte gebaut um geschrieben warte jetzt auf meine ESP8266-12E Boarde die kommen aus China mein Glück auf deine Seite entdeckt zu haben
    Danke Für dein hilfreichen Beitrag

    Gruß Andreas

  28. Frank Häfele sagt:

    Hallo,

    Vielen Dank für den tollen Beitrag! Ist wirklich gelungen!
    Ich habe mich gleich dran gemacht die Beispiele nach zu machen.
    Aber beim Auslesen der Dallas Temperatur scheitere ich gerade.
    Anstatt einer Temperatur auf dem seriellen Monitor zeigt es hier folgende Zeichen an:

    ###
    ⸮⸮(⸮(S⸮뛛⸮+⸮⸮++d⸮d⸮(+3c⸮˛⸮⸮P⸮⸮d⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮+⸮⸮d⸮k⸮;⸮⸮d⸮d⸮⸮⸮⸮d⸮⸮⸮⸮⸮k⸮$⸮SSț⸮[⸮⸮⸮⸮⸮⸮S⸮d⸮+++++⸮$c⸮⸮37⸮⸮⸮⸮⸮⸮$d⸮P⸮++k⸮⸮⸮⸮⸮⸮⸮P⸮⸮⸮⸮⸮+++C⸮[⸮
    ###

    Kannst Du mir sagen/weiterhelfen woran das liegen könnte?

    Viele Grüße
    Frank

    1. Frank Häfele sagt:

      Ok, Problem gelöst…
      Die Baudrate des seriellen Monitors war auf 9600 eingestellt anstatt auf 115200 🙂

  29. Castle sagt:

    Nice guide.

  30. Philip sagt:

    Super Artikel- vielen Dank!

  31. hh sagt:

    Hallo Frank !
    Es ist einfach traumhaft !!! solche Beiträge wie hier zu finden
    Ich habe noch keine Sachen wie hier beschrieben, aber habe RIESEN-Lust bekommen in diese Welt der hier gezeigten Programmierung einzusteigen
    Danke für diesen tollen Beitrag
    hh

  32. Ogon sagt:

    Hallo, kann mir jemand behilflich sein das Beispiel auf zwei wifi Temperaturänderungen und keine Lokale umzustricken ? Komme einfach nicht weiter ….

  33. Marco sagt:

    Hallo
    der Artikel und die Umsetzung sind echt super geworden …
    Habe aber leider nicht genug Erfahrung für eine Erweiterung …
    Hat Jemand die Möglichkeit mir zu helfen ?

  34. Ingo sagt:

    Ein Update bzgl. der Baudrate: alle Pakete, die jünger als 2.5.0 sind, bieten keine 9600’er Bautrate an. Mittlerweile kann ich aber auch mit den anderen Geschwindigkeiten flashen. Warum auch immer das vorher nicht ging…
    Jetzt kann ich endlich mit dem Artikel weiter machen. 🙂

  35. Helmut Wunder sagt:

    hallo,
    danke für eure Projekt-Beispiele zu ESP8266, die mir schon viel geholfen haben!
    Was ich hingegen schon lange suche und absolut nicht zum Laufen bekomme:
    Eine Möglichkeit, dieses Beispiel auch über einen ESP32 zu hosten – statt über den esp8266 Server –
    – gerne auch mit einem simplen SSD1306 OLED statt einem ILI9340 .
    Dummerweise laufen eure ESP8266-Server-Programme nicht auch auf einem ESP32 (inkompatible WifiServer und WebServer Libs), sodass ich ESP8266-Code nicht mit einem ESP32 zum Laufen kriege.
    Es ist wirklich frustrierend.
    Könntet ihr eventuell so etwas ähnliches einmal konstruieren und vorstellen?
    Vielen Dank im vorraus und viele Grüße
    Helmut Wunder

    1. Frank sagt:

      Zum ESP32 kann ich Dir leider nichts sagen, damit habe ich mich noch nicht beschäftigt!

  36. Ulrich Bolik sagt:

    Hallo Frank,
    habe Deine Anleitung gelesen und gleich ein nodeMCU_ESP8266 bestellt. Kam auch sehr schnell an, ist aber ein 12F. Nach anfänglichen Schwierigkeit habe ich das Board angeschlossen bekommen und Dein Blink-Sketch hochgeladen. Die LED of dem Board blinkt auch beim Hochladen, geht aber danach aus und bleibt dunkel. Das Programm scheint nicht zulaufen. Hast Du noch irgendeinen Tipp, was ich ausprobieren könnte?
    Viele Grüße
    Ulrich

  37. Ulrich Bolik sagt:

    Kommando zurück: Mit LED = D$ funktioniert’s. Sorry für meinen Schnellschuß.

  38. Franz Moser sagt:

    Hallo, bin begeistert!
    Mit dieser Anleitung kann man in viele Bereiche reinschnuppern. Mein Zeug:2x NodeMCU Lolin V3, 2x 20×4 I2C Zeichen LCD-Display. soweit funktioniert es ganz gut. Nun habe ich mir ein 3,5 Zoll (320×480) TFT LCD SPI besorgt, bei der Anpassung (ILI9340) zur (ILI9488) hab ich aber Probleme. kann mich da wer helfen?
    lg franz

  39. Martin Kirchner sagt:

    Ein wirklich super Artikel zu dem Thema der mir extrem geholfen hat.
    Vielen Dank für die Mühe!!

    martin

  40. Michael Jung sagt:

    Hallo Frank, ich bastel jetzt schon die Zweite Anlage. Eine steht bei uns. Mein Enkel hat uns besucht nun wünscht er sich auch eine. Ich habe viel gelernt dabei. Ich bin 77 und die Arbeiten fordern mich.

    1. Frank sagt:

      Das freut mich sehr

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

scroll to top