NodeMCU und ESP8266 – Einstieg in die Programmierung

NodeMCU-Einstieg-mit-arduino-ide

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.

Letzte Aktualisierung am 29.03.2017 / Affiliate Links / Bilder von der Amazon Product Advertising API

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 http://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 http://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.

Letzte Aktualisierung am 29.03.2017 / Affiliate Links / Bilder von der Amazon Product Advertising API

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 http://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 http://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 http://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

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

Martin Mohr - entwickler.press - Gebundene Ausgabe: 152 Seiten

24,90 EUR

Letzte Aktualisierung am 29.03.2017 / Affiliate Links / Bilder von der Amazon Product Advertising API

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

Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer*

Erik Bartmann - Elektor - Auflage Nr. 2 (14.11.2016) - Taschenbuch: 440 Seiten

39,80 EUR

Letzte Aktualisierung am 29.03.2017 / Affiliate Links / Bilder von der Amazon Product Advertising API

 

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 http://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
×

13 Gedanken zu “NodeMCU und ESP8266 – Einstieg in die Programmierung

  1. Christian

    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

    Antworten
    • Frank Autor des Beitrags

      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

      Antworten
  2. Sascha

    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

    Antworten
    • Frank Autor des Beitrags

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

      Antworten
  3. Tobias

    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

    Antworten
    • Tobias

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

      Antworten
    • Frank Autor des Beitrags

      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

      Antworten
  4. Tobias

    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

    Antworten
    • Frank Autor des Beitrags

      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.

      Antworten
      • Tobias

        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

        Antworten
        • Frank Autor des Beitrags

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

          Antworten

Schreibe einen Kommentar

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

Top