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.
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?
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:
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.
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
Pinbelegung eines NodeMCU-Boards (hier Version 2)
Bei der Pinbelegung in den oberen Zeichnungen ist zu beachten, dass nicht alle Signale und Ports zur freien Verfügung stehen. Einige Ports sind auf dem NodeMCU-Board oder auch ESP-12E-Modul selbst in Verwendung.
Hier eine Liste der intern verwendeten Signale
D0 GPIO16 Rote Led liegt mit Kathode an (kann dennoch verwendet werden) MISO GPIO7 Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet MOSI GPIO8 Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet D11 GPIO9 Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet D12 GPIO10 Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet GPIO11 Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet GPIO06 Wird zur Ansteuerung des externen Flash auf dem ESP12E Modul verwendet RXD0 GPIO3 Wird für USB-Schnittstelle benötigt TXD0 GPIO1 Wird für USB-Schnittstelle benötigt D4 GPIO2 Blaue LED des ESP12E Moduls D3 GPIO0 Geht an Taster FLASH, kann jedoch ansonsten genutzt werden
Zur Info die untere Schaltungsskizze zeigt noch mal die interne Verschalung der Tasten auf dem NodeMCU-Board. Die hier angegebene blaue LED war bei den vorliegenden Modulen allerdings rot und nicht blau.
Der praktische Einstieg mit dem NodeMCU-Board
Man könnte noch viel zu den ESP8266-Modulen und auch zum NodeMCU-Board schreiben, aber ich will mich hier auf das Wesentliche beschränken und lieber ein praktisches Anwendungsbeispiel zeigen. Zudem gibt es schon viele Internet-Seiten als auch Bücher (siehe ESP8266-Buchvorstellung) die sehr viele Infos zu der ESP-Serie liefern und zum zweiten macht das Lernen einfach mehr Spaß wenn man schnell zu praktischen Ergebnissen kommt. Daher beschränke ich mich hier auf die Schritte und das Wissen, das Ihr benötigt um ein erstes erfolgreiches Projekt umzusetzen. Am Ende des Beitrages habt Ihr ein Thermometer mit Farbdisplay, das die Innentemperatur und Außentemperatur anzeigt. Auch per Browser werdet Ihr die Temperaturen abrufen können. Basis werden zwei NodeMCU-Boards sein, wobei das eine als Empfänger / Server und Anzeige fungiert und das andere die Außentemperatur misst und zur Anzeige (zum Server) sendet.
Mit diesem Wissen dürfte es Euch dann leicht fallen auch andere und komplexere Dinge umzusetzen, bekanntlich ist der erste Schritt immer der schwierigste.
Schritt 1 – Das richtige NodeMCU-Board kaufen
Um die nachfolgenden Schritte nachzuvollziehen benötigt Ihr zunächst mal ein NodeMCU-Board. Am besten kauft Ihr euch gleich zwei, da wir später wie bereits beschrieben zwei für unser Projekt benötigen. Ihr findet geeignete Module hier bei Ebay* oder hier bei Amazon*. Achtet möglichst beim Kauf darauf, dass das Modul als USB-Wandler den Chip CP2102 verwendet, das hat nämlich den Vorteil dass Ihr unter neueren Betriebsystemen (Windows 7 / 8 / 10) keinen Treiber installieren müsst, da Windows diesen bereits besitzt. Ihr erkennt diesen Chip an der kleinen quadratischen Bauform. Man kann zwar auch die Module mit CH341-Chip einsetzen, muss dann aber einen Treiber installieren. Beim Download eines solchen Treibers muss man dann immer aufpassen dass man sich nicht versehentlich auch Viren einschleppt, was ich bei China-Downloads schon öfters mal erlebt habe. Am billigsten bekommt Ihr die Module natürlich bei Ebay* direkt aus China, allerdings müsst ihr dann auch 3 bis 4 Wochen Lieferzeit einkalkulieren.
Da ich immer etwas ungeduldig bin, habe ich auf ein Prime-Angebot von einem Amazon Händler zurückgegriffen und zwei Module von SeeedStudio gekauft. Hier sind ein paar geeignete Varianten, bei den billigsten Amazon-Angeboten wird gewöhnlich ebenfalls aus dem Ausland geliefert, also auch da die Lieferzeit beachten.
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.
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.
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:
Nachdem Ihr die Voreinstellungen wieder mit OK verlassen habt, könnt Ihr im Menü Werkzeuge den Menüpunkt Board… und danach Boardverwaltung auswählen.
In der Boardverwaltung sucht Ihr jetzt nach ESP8266, in der Regel solltet Ihr es auch finden wenn ihr dort ganz nach unten scrollt. Wenn Ihr darauf klickt, dann erscheint ein Auswahlfeld für die Version und ein Installieren-Button.
Achtung 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.
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.
Nachdem Ihr euer gekauftes NodeMCU neu geflasht habt, könnt Ihr also zurück zu Schritt 4 gehen und das Ganze noch mal versuchen. Spätestens jetzt sollte eigentlich alles klappen.
Falls du auch mal unter Lua-Programmieren willst, dann kann ich übrigens folgende Links empfehlen:
- NodeMCU – Dokumentation (englisch)
- NodeMCU / Lua tutorial (englisch)
- Offizielle Lua Hompage (englisch)
- Deutsche Übersetzung der Lua Doku
- Buch Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer (deutsch)* / Review auch hier
Mit der NodeMCU-Programmierung loslegen
Mit NodeMCU_Board Temperatursensor DS 18B20 auslesen
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:
Falls Ihr bereits die normale DallasTemperature-Lib installiert habt, müsst Ihr diese deinstallieren oder einfach aus dem Verzeichnis C:\Users\DeinBenutzername\Documents\Arduino\libraries löschen. Ansonsten weiß die Arduino IDE nicht welche sie benutzen soll und nimmt die falsche. Oft wird das beim Compilieren als Warnung zwar angezeigt, jedoch auch überlesen da es schnell weg gescrollt wird.
Die Onwire und Base-Library dagegen, die auch in dem nachfolgenden Beispiel Verwendung findet, kann ganz normal und bequem über die Arduino-IDE (Menüpunkt Sketch / Bibliothek einbinden) heruntergeladen und installiert werden.
Das nachfolgende Beispiel liest den Temperatursensor DS18B20 aus und gibt die Temperatur über die serielle Schnittstelle im 2 Sekunden Takt aus. Nachdem Ihr das Programm übertragen habt, könnt ihr den “Seriellen Monitor” der Arduino IDE starten und die Temperaturausgaben verfolgen.
Die seriellen Monitor zum Überwachen der NodeMCU Ausgaben startet Ihr mit dem Lupensymbol rechts oben in der Arduino IDE, siehe Foto.
Die Ausgaben sollten bei unserem jetzigen Beispiel (unterer Sketch) in etwa wie unten abgebildet aussehen. Erscheinen dort unleserliche Zeichen, dann müsst ihr in der rechten unteren Ecke eventuell die Baudrate anders wählen. Die eingestellte Baudrate muss der Baudrate entsprechen, die ihr im Sketch mit folgendem Befehl angegeben habt:
Serial.begin(115200);
Hier die Schaltung:
Hier der Programmcode (Sketch)
/* NodeMCU-DallasDS18B20 Led an dem Modul ESP8266 bzw. Board NodeMCU blinken lassen und Temperatursensor an Pin D1 auslesen Notwendig ist die angepasste Dallas-Lib: Download hier: https://github.com/milesburton/Arduino-Temperature-Control-Library Eine eventuell vorhandene DallasTemperature-Lib sollte gelöscht werden, damit oben genannte von der IDE verwendet wird Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX Bezugsquelle NodeMCU Board: http://amzn.to/2iRkZGi Programm erprobt ab Arduino IDE 1.6.13 Weitere Beispiele unter https://www.mikrocontroller-elektronik.de/ */ #define LED D0 //Interne Led auf dem NodeMCU Board LED_BUILTIN #include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird //https://github.com/milesburton/Arduino-Temperature-Control-Library #include <Base64.h> #include <OneWire.h> #define ONE_WIRE_BUS D1 //Bestimmt Port an dem der Sensor angeschlossen ist OneWire oneWire(ONE_WIRE_BUS); DallasTemperature DS18B20(&oneWire); char temperaturStr[6]; void setup() { pinMode(LED, OUTPUT); // Port aus Ausgang schalten Serial.begin(115200); DS18B20.begin(); } float getTemperatur() { float temp; do { DS18B20.requestTemperatures(); temp = DS18B20.getTempCByIndex(0); delay(100); } while (temp == 85.0 || temp == (-127.0)); return temp; } void loop() { digitalWrite(LED, LOW); //Led port ausschalten delay(1000); //1 Sek Pause digitalWrite(LED, HIGH); //Led port einschlaten delay(1000); float temperatur = getTemperatur(); dtostrf(temperatur, 2, 2, temperaturStr); Serial.print("Temperatur: "); Serial.println(temperaturStr); }
NodeMCU steuert QVGA-Farbdisplay an und gibt Temperatur aus
Wir haben gesehen wie einfach man so ein NodeMCU-Board* programmieren kann und wie einfach man Ausgaben über das USB-Kabel zum PC zurückschicken und anzeigen lassen kann. Natürlich wäre es viel schöner wenn man die Temperatur oder auch andere Dinge auf einem eigenen kleinen Display ausgeben könnte. Auch das ist kein Problem, im nachfolgende Sketch steuern wir ein Grafik-Farbdisplay per SPI an. Ein solches Display bekommt man z.B. für ein paar Euro bei Amazon* oder Ebay*. Das Beispiel funktioniert aber auch bei ähnlichen Displays die den selben Displaycontroller ILI9340 nutzen.
Keine Produkte gefunden.
Auf der Rückseite sieht ein solches Display zum Beispiel so aus:
Viele dieser Displays haben auch einen Sockel für eine SD-Karte auf der Rückseite, um das Beispiel einfach zu halten nutzen wir diesen im unteren Sketch nicht. Die Ansteuerung ist dadurch relativ einfach und der Sketch sehr übersichtlich, da wir auch hier wieder auf vorhandene Arduino Libraries zurückgreifen können. Für das Beispiel brauchen wir zusätzlich folgende Libraries:
- Adafruit_GFX
- Adafruit_ILI9340
Die erste kann wieder bequem über die Arduino-IDE installiert werden. Die zweite wird wieder in einer für NodeMCU (bzw. ESP8266) angepassten Version benötigt, diese kann man hier herunterladen:
Schaltplan / Skizze – NodeMCU mit Display und Tmperatursensor DS18B20
Wie das Ganze verschaltet wird, sieht man auch unten in der Schaltungsskizze.
Display Verbunden mit VCC 3,3V GND GND CS GND RST RESET D/C D1 SDI/MOSI D7 SCK D5 LED 3,3 V SDO/MISO D6
Unser neuer Programmcode (Sketch) für die Display Ansteuerung und Temperaturanzeige
Das NodeMCU-Board misst zwei mal pro Sekunde die Temperatur. Ergibt sich eine Temperaturveränderung so wird diese auf dem Display ausgegeben. Wir haben also ein elektronisches Thermometer, welches sehr genau ist. Die Temperatur wird mit einer Nachkommastelle ausgegeben. Das Beispiel ist bewusst einfach gehalten, man könnte die Ausgabe natürlich noch hübscher gestalten, die Grafik Library bietet dafür zahlreiche Befehle die man verwenden könnte.
/* NodeMCU-TFT-Temperatur TFT-Display mit Controller ILI9341 am NodeMCU-Board Verwendetes Display: 2.2 Zoll Serial TFT-Farbdisplay; SPI; Auflösung 240x320 Pixel Bezugsquellen Display: Amazon - http://amzn.to/2iNmaXx / Amazon - http://amzn.to/2j1VIXK Temperatur wird über angeschlossenen Sensor DS18B20 ausgelesen und auf dem Display angezeigt Temperatursensor DS18B20 an Pin D2 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX Notwendig ist die angepasste Display-Lib: https://github.com/glennirwin/Adafruit_ILI9340 Programm erprobt ab Arduino IDE 1.6.13 Projektbeschreibung und weitere Beispiele unter https://www.mikrocontroller-elektronik.de/ */ #include "SPI.h" #include "Adafruit_GFX.h" #include "Adafruit_ILI9340.h" // https://github.com/glennirwin/Adafruit_ILI9340 #include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird https://github.com/milesburton/Arduino-Temperature-Control-Library #include <Base64.h> #include <OneWire.h> #define ONE_WIRE_BUS D2 OneWire oneWire(ONE_WIRE_BUS); DallasTemperature DS18B20(&oneWire); char temperaturStr[6]; float merketemperatur=0; //Pinbelegung für Display #define TFT_CS D0 // GPIO 16 interne LED kein Port nötig, da TFT CS an GND #define TFT_RST 10 // D12 GPIO10 //kein Port nötig, da Reset an Reset angeschlossen #define TFT_DC D1 // GPIO 5 #define TFT_MOSI D7 // GPIO 13 #define TFT_CLK D5 // GPIO 14 #define TFT_MISO D6 // GPIO 12 Adafruit_ILI9340 tft = Adafruit_ILI9340(TFT_CS, TFT_DC, TFT_RST); //Falls die Anzeige gedreht wird #define ROTATION_NO 0 #define ROTATION_90 1 #define ROTATION_180 2 #define ROTATION_270 3 void setup() { DS18B20.begin(); Serial.begin(115200); tft.begin(); tft.setRotation( ROTATION_270); tft_zeichneRahmen(); tft_zeichneBeschriftung(); } void tft_zeichneBeschriftung(void) { tft.setTextColor(ILI9340_WHITE); tft.setCursor( 10,55); tft.setTextSize(2); tft.print("Innentemperatur in "); tft.setTextSize(1); tft.print("O"); tft.setTextSize(3); tft.print("C"); tft.setTextSize(1); tft.setCursor( 50,15); tft.print("www.Mikrocontroller-Elektronik.de"); tft.setTextSize(2); tft.setCursor( 10,210); tft.print("NodeMCU Beispiel"); } void tft_zeichneRahmen( ) { tft.fillScreen(ILI9340_BLACK); tft.drawRoundRect(1, 0, tft.width()-1,40, 10, ILI9340_BLUE); tft.drawRoundRect(1, 50, tft.width()-1,135, 10, ILI9340_GREEN); tft.drawRoundRect(0, 200, tft.width()-1, 40, 10, ILI9340_RED); } float getTemperatur() { float temp; do { DS18B20.requestTemperatures(); temp = DS18B20.getTempCByIndex(0); delay(100); } while (temp == 85.0 || temp == (-127.0)); return temp; } void zeigeTemperatur(float temperatur) { dtostrf(temperatur, 2, 1, temperaturStr); Serial.print("Temperatur: "); Serial.println(temperaturStr); tft.setTextSize(10); tft.setTextColor(ILI9340_YELLOW, ILI9340_BLACK ); tft.setCursor(20,90); tft.print(temperaturStr); } void loop(void) { delay(500); float temperatur = getTemperatur(); if (merketemperatur!=temperatur) { zeigeTemperatur(temperatur); merketemperatur=temperatur; } }
Wir programmieren einen ESP-Server und ESP-Client um Temperaturwerte per WLAN zu übertragen
Wir haben jetzt zwar mit der Temperaturanzeige schon ein erste praktisches Beispiel gesehen was mit dem NodeMCU-Board umgesetzt werden kann, allerdings wurden bislang noch nicht die eigentlichen WLAN-Fähigkeiten verwendet. Alles was wir bisher gemacht haben wäre auf einem Arduino Uno genauso möglich gewesen. Jetzt wollen wir aber auch noch die Außentemperatur mit auf die Anzeige bringen und dazu können wir WLAN einsetzen.
Wir werden also zwei NodeMCU-Boards einsetzen, eines immer Innenbereich für die Anzeige und eines um die Außentemperatur zu messen und per WLAN zu übertragen.
Die ESP-Module bzw. NodeMCU kann in mehreren Betriebsarten verwendet werden. Es kann als Server, Access-Point oder Client konfiguriert werden. Es gibt also gleich mehrere Möglichkeiten unser Vorhaben umzusetzen.
Wir haben folgende Konstellation gewählt:
Unsere Außenstation, welche die Außentemperatur ermittelt, wird als Client arbeiten. Hier wird also nur ein Temperatursensor an das NodeMCU-Board angeschlossen, praktisch wie in unserem ersten Beispiel.
Das zweite NodeMCU-Board wird mit einem Temperatursensor für den Innenbereich und dem Farbdisplay verdrahtet, also genauso wie oben im letzten Beispiel.
Im Grunde brauchen wir also nur den Programmcode zu verändern um unser Ziel zu erreichen.
Das NodeMCU-Board im Innenbereich werden wir im Sketch so konfigurieren, dass es als Server fungiert und sich in ein vorhandenes WLAN-Netz integriert. Wir werden dem Board im Sketch eine feste IP geben, so dass wir stets wissen wie unser Board mit dem Display erreichbar ist.
Ihr müsst also in dem unteren Sketch die SSID und das Passwort eures hauseigenen WLAN-Netzes eintragen (entsprechende Stellen sind mit einem Kommentar versehen).
Das NodeMCU-Board im Außenbereich braucht ebenfalls eure WLAN-Zugangsdaten, die IP kann hier aber dynamisch über den Router (DHCP-Server) geholt werden. Damit sich der Strombedarf in Grenzen hält, wird dieses Board die Temperatur in zeitlichen Abständen von 15 Minuten an den Server übertragen. Die Zeit könnt ihr im Sketch frei einstellen. Zwischen diesen Zeiten wird sich das Board schlafen legen.
Als Übertragungsart nutzen wir quasi einen URL-Aufruf, bei dem die Temperaturwerte von außen an den Server mit Display übertragen werden. Dies hat den Vorteil, dass die Werte sehr leicht beim Server dekodiert werden können und zudem könnt Ihr probeweise auch per Browser Daten zur Anzeige übertragen.
Eine solche Aufruf würde wie folgt aussehen:
http://192.168.2.75/sensor/temperatur/?wert=20
Bei diesem Aufruf gehen wir davon aus, dass Ihr eurem NodeMCU- Server die feste IP 192.168.2.75 zugeteilt habt, ihr könnt natürlich auch eine andere verwenden. Wir haben hier als Unterseite „/sensor/temperatur/“ bei Server definiert, eure Temperatur, die hier als „wert=20“ übergeben wird, wird nach Eingabe der URL sofort am Server empfangen und auf dem Display angezeigt. Das hilft beim debuggen.
Man könnte natürlich noch weitere Werte übertragen, beispielsweise mit diesem Aufruf:
http://192.168.2.75/sensor/temperatur/?pw=passwortxyz&nr=1&wert=20
Man könnte also zum Beispiel auch ein Passwort mit angeben, damit Fremde, welche die URL kennen, nicht missbräuchlich unberechtigte Daten übertragen. Der Server könnte also beispielsweise alle Aufrufe mit falschen Passwort einfach ignorieren. Der Übersichtlichkeit halber werden momentan Passort und weitere Parameter nicht ausgewertet, sind aber möglich.
Die fertige Schaltung für unseren Außensensor mit WLAN-Sender
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.
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.
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
Letzte Aktualisierung am 2024-12-07 / * Affiliate Links
Links zum Thema
- ESP12E-Tutorial und ESP-Adapter-Projekt
- NodeMCU – Projektseite (Englisch) – Beschäftigt sich vorwiegend mit Lua als Programmiersprache
- Flash-Tool mit integrierter Firmware
- Datenblatt zum USB-Chip CP2102
- Hersteller der ESP8266-Serie spressif.com
- Schaltplan zum NodeMCU-Board
- Schaltplan eines ESP12 Moduls (Reverse engineered)
- ESP12E-Pinbelegung (PDF)
- ESP12E Programmierung über seriellen Adapter
- Neues deutsches Forum zum NodeMCU-Board und der ESP8266-, ESP32-Serie
- Englisches Forum zum ESP8266 / NodeMCU
- Tipps und Hinweise zur Arduino ESP8266 / ESP12E Programmierung und Lib
- Energiesparende Alternative zu WLAN = RFM12B
- Bezugsquelle für NodeMCU Amazon* / Ebay*
- Bezugsquelle für ESP8266 Modul ESP12-E Amazon* / Ebay*
- Deutsche Bücher zu NodeMCU und ESP8266
- Farbcode Picker für individuelle Farben auf dem gezeigten SPI-Display
- Tipps/Beispiele zu den Befehlen der verwendeten Arduino Adafruit GFX Library
Links vorwiegend für LUA-Programmierer
- NodeMCU – Dokumentation (englisch)
- NodeMCU / Lua tutorial (englisch)
- Offizielle Lua Hompage (englisch)
- Deutsche Übersetzung der Lua Doku
- Buch Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer (deutsch)* / Review auch hier
- ESPlorer -Beliebte Entwicklungsumgebung für Lua Programmierer
- MSXFAQ – Blog
Weitere Hinweise
Vor dem Aufbau bitte nachfolgende Hinweise lesen:Das Projekt unterliegt einer CC-Lizenz - Lizenzhinweis (zum Aufklappen anklicken)
Falls Dir der Beitrag gefallen oder geholfen hat kannst Du dem Autor aber gerne durch eine kleine Spende Danke sagen!
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
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
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.
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*“
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
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).
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
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;
}
Danke für den hilfreichen Hinweis und natürlich auch das Lob.
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!
Die onboard LED des NodeMCU spricht man mit D4 oder Pin 2 an.
Gruß, Sector
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
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
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.
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
Merkwürdiges Verhalten.Ich denke nicht das er geschlafen hat, vielleicht war einfach Programm nicht richtig übertragen oder fehlerhaft. Aber Hauptsache es geht wieder.
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
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.
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
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.
Hallo Frank,
dein tolles Tutorial hat mir den Einstieg deutlich vereinfacht!
Vielen Dank dafür!
Gruß Falk
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
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.
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.
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.
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?
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.
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
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.
Danke!
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
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
Kann ich Dir nichts sagen, kenne diese Funkmodule nicht näher.
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?
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.
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
Zu den AT-Befehlen kann ich Dir nichts mehr sagen, die habe ich schon lange nicht mehr genutzt.
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
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.
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.
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
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.
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.
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.
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
Die Loop Funktion wird bei Arduino immer in einer Schleife aufgerufen.
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
Schau auch mal in den Beitrag DS18S20
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
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!
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!!!
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…
Das ist nicht normal, bei korrekter Pinbelegung wie beschrieben muss Programm auch neu start. Ich ziehe oft Stecker, hatte noch nie Probleme.
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.
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
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
Ok, Problem gelöst…
Die Baudrate des seriellen Monitors war auf 9600 eingestellt anstatt auf 115200 🙂
Nice guide.
Super Artikel- vielen Dank!
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
Hallo, kann mir jemand behilflich sein das Beispiel auf zwei wifi Temperaturänderungen und keine Lokale umzustricken ? Komme einfach nicht weiter ….
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 ?
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. 🙂
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
Zum ESP32 kann ich Dir leider nichts sagen, damit habe ich mich noch nicht beschäftigt!
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
Kommando zurück: Mit LED = D$ funktioniert’s. Sorry für meinen Schnellschuß.
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
Ein wirklich super Artikel zu dem Thema der mir extrem geholfen hat.
Vielen Dank für die Mühe!!
martin
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.
Das freut mich sehr