Home / Programmieren / Arduino - ESP8266

Arduino - ESP8266

Diese Seite beinhaltet

Ergänzende Seiten zum:


Auch wenn diese Seite unter der Rubrik „Programmieren“ zu finden ist, ist Arduino eigentlich keine eigene Programmiersprache, sondern ein Open‑Source‑Projekt. Es umfasst verschiedene Entwicklerboards und die Arduino‑IDE (Programmiereditor und mehr). Als Programmiersprache dient eine auf C/C++ basierende, vereinfachte Sprache. Bei Arduino werden Programme übrigens als „Sketch“ (Skizze) bezeichnet.

Das allererste Arduino‑Board entstand 2005 auf Basis eines Atmel ATmega8‑Controllers durch Massimo Banzi und David Cuartielles in Italien. Das erste kommerzielle Board war der „Arduino RS232“. Das heute bekannteste Board dürfte der Arduino Uno sein. Aufgrund des Open‑Source‑Konzepts gibt es jedoch zahlreiche Hardware von Drittanbietern. Diese ist zu 100 % kompatibel, darf aber nicht „Arduino“ im Namen tragen.

Eines dieser Entwicklerboards ist der „Wemos D1 mini“ auf Basis des ESP8266. Grundsätzlich lässt sich das hier Gezeigte aber auch auf allen anderen ESP8266‑Boards oder „nackten“ ESP‑Modulen umsetzen. Der ESP8266 der chinesischen Firma Espressif ist ein 32‑Bit‑Mikrocontroller mit integriertem WLAN. Klein bei Stromaufnahme, Abmessungen und Preis, aber groß in der Flexibilität – ein idealer Baustein für selbstgebaute IoT‑Geräte.




Arduino IDE

Installation:
Ich als bekennender Liebhaber von Portable-Apps habe meine Arduino IDE unter Windows wie folgt installiert: Zunächst habe ich mir die Version 1.8.16 auf der offiziellen Arduino-Seite unter Old Releases heruntergeladen. Dann das Setup in einer Virtuellen Maschine (Win7) installiert und den kompletten Installationsordner (C:\Program Files (x86)\Arduino) auf meinen "physischen" Rechner kopiert. Im Anschluss fügt man noch den Ordner "portable" hinzu und voilà, fertig ist die Portable-Arduino-IDE. Gestartet wird die IDE über die "Arduino.exe". Alle App-Downloads und Einstellungen wandern den Ordner "portable" und können z.B. per USB vom einen zum anderen Rechner mitgenommen werden.

Ich als bekennender Liebhaber von Portable‑Apps habe meine Arduino‑IDE unter Windows wie folgt installiert: Zunächst habe ich mir die Version 1.8.16 auf der offiziellen Arduino-Seite unter „Old Releases“ heruntergeladen. Anschließend habe ich das Setup in einer virtuellen Maschine (Windows 7) installiert und den kompletten Installationsordner (C:\Program Files (x86)\Arduino) auf meinen „physischen“ Rechner kopiert.

Im Anschluss fügt man noch den Ordner „portable“ hinzu und voilà – fertig ist die portable Arduino‑IDE. Gestartet wird die IDE über die „arduino.exe“. Alle App‑Downloads und Einstellungen landen im Ordner „portable“ und können z.B. per USB von einem zum anderen Rechner mitgenommen werden.

ESP8266 Board-Installation:
Die ESP8266‑Bibliothek ist nicht Bestandteil der Standardinstallation und muss nachträglich installiert werden.. Dazu im Hauptmenü:

USB-Treiber:
Zum Abschluss der Installation muss noch der USB‑Treiber des Wemos‑Boards installiert werden. Dabei handelt es sich um einen USB‑zu‑Seriell‑Treiber vom Typ CH340, der hier direkt heruntergeladen werden kann.

CH340 Treiber  (180 KB)


Board-Auswahl

Mit der Installation des Board‑Pakets werden eine ganze Reihe ESP8266‑basierter Boards in der Arduino‑IDE verfügbar. Um für den D1 mini das richtige Board auszuwählen, geht man auf "Werkzeuge/Board/ESP8266 Boards" und wählt dort "LOLIN (WEMOS) D1 mini (clone)" aus.




COM-Port
Damit die Arduino‑IDE mit dem USB‑Adapter und damit letztlich auch mit dem ESP kommunizieren kann, muss der COM‑Port des Adapters angegeben werden. Hierzu ermittelt man zunächst über den Windows‑Gerätemanager den dem Adapter zugewiesenen COM‑Port. In meinem Fall ist das COM7.


Blinktest

Nachdem die Installation abgeschlossen ist, kann man das Board per Micro‑USB‑Kabel an den PC anschließen und in der Arduino‑IDE einen ersten einfachen Beispiel‑ und Test‑Sketch hochladen und ausführen. Dieser Sketch tut nichts weiter, als die blaue Status‑LED des Boards blinken zu lassen. Dazu wählt man im Menü "Datei/Beispiele/01.Basics/Blink", und schon wird der Sketch in der IDE geöffnet. Durch einen Klick auf den Button "Hochladen" wird der Sketch kompiliert, auf den ESP8266 übertragen und anschließend gestartet.

Hat alles geklappt, sollte die blaue LED nun mit einer Frequenz von etwa 1 Hz blinken. Um die Blinkfrequenz zu ändern, sucht man im Code nach den beiden delay‑Aufrufen und passt deren Werte nach Belieben an. Die Angabe erfolgt in Millisekunden. Nach einem erneuten Klick auf den Button "Hochladen" wird der geänderte Sketch an den Mikrocontroller übertragen und direkt wieder ausgeführt.


Code Aufbau und Serieller Monitor

Bevor es nun richtig losgeht, noch ein paar Worte zum Code‑Aufbau und zum Seriellen Monitor. Ein Arduino‑Sketch teilt sich grob in drei Bereiche auf. Ganz oben (rot) werden die für das Programm benötigten Module (Libraries) eingebunden sowie globale Variablen und Konstanten definiert.

Im Bereich void setup() (blau) stehen alle initialisierenden Anweisungen, die nur einmal beim Programmstart ausgeführt werden, z.B. das Starten von WLAN und Webserver sowie das Initialisieren des Seriellen Monitors – dazu gleich mehr.

Im dritten Abschnitt void loop() (grün) befindet sich der sich ständig wiederholende Programmteil, also das Warten auf Ereignisse und die Reaktionen darauf. All das wird im nächsten Abschnitt „WLAN“ noch deutlicher werden.

Der Serielle Monitor ist ein sehr nützliches Werkzeug. Er dient als Ausgabefenster des ansonsten anzeigelosen ESP8266. Zum einen kann man sich hier den Programmfortschritt anzeigen lassen, zum anderen lässt er sich durch gezielte Ausgaben als Debugging‑Hilfe einsetzen.

Wie bereits oben erwähnt, muss er zunächst im Programmbereich void setup() initialisiert werden. Das geschieht über die Zeile:

Serial.begin(9600);

Dabei steht 9600 für die Übertragungsrate in Baud. Das Monitorfenster selbst wird über das Menü "Werkzeuge/Serieller Monitor" oder über die Tastenkombination [Strg] + [Umschalt] + [M] geöffnet.

Wichtig ist, dass die im Code angegebene Baudrate auch im Monitorfenster eingestellt wird, sonst wird man nicht viel Brauchbares sehen. Ich nutze hier meist die Standardeinstellung 9600 Baud, viele Sketch‑Beispiele im Netz verwenden jedoch höhere Werte, die entsprechend im Code und im Monitorfenster abgeglichen werden müssen.    

Um eine Ausgabe im Seriellen Monitor zu platzieren, können die Befehle print bzw. println verwendet werden. Dabei sendet println am Ende der Ausgabe einen Zeilenumbruch, print hingegen nicht.

Beispiel: Serial.println("Hallo Welt");

gibt den Text "Hallo Welt" inklusive Zeilenumbruch im Seriellen Monitor aus.


WLAN

Am Router im Heimnetzwerk anmelden

Im folgenden Sketch baut der ESP8266 eine WLAN-Verbindung zum heimischen Netzwerk (Router) auf. Damit sich auch etwas tut, erhält er zusätzlich einen einfachen Webserver, der auf die beiden URLs "/led_ein" und "/led_aus" reagiert. Über diese beiden URLs lässt sich die blaue Status-LED am ESP8266 ein- und ausschalten.

Der Webserver stellt eine einfache Startseite mit zwei Links zu diesen beiden URLs bereit. Der zugehörige HTML-Code wird direkt nach dem Laden der WLAN- und Webserver-Module in die Variable html geschrieben.

Der komplette Sketch kann per Copy & Paste in die Arduino-IDE übernommen werden; lediglich die WLAN-Zugangsdaten (ssid und pwd) müssen zuvor angepasst werden. Der Code ist vollständig kommentiert, sodass die einzelnen Aktionen gut nachverfolgt werden können.

Nachdem der Code kopiert und die beiden Variablen ssid und pwd angepasst wurden, öffnet man den Seriellen Monitor mit [Strg] + [Umschalt] + [M] und klickt anschließend auf "Hochladen" (bzw. verwendet die Tastenkombination [Strg] + [U]).

Ist der Sketch kompiliert und hochgeladen, startet der ESP8266 automatisch neu und baut eine Verbindung zum Heimnetzwerk auf. Läuft alles wie geplant, wird im Seriellen Monitor die vom Router vergebene IP-Adresse angezeigt. In meinem Fall ist dies 192.168.178.76 - bei dir wird es mit an Sicherheit grenzender Wahrscheinlichkeit eine andere Adresse sein.

Diese IP-Adresse kopiert man nun in die Adresszeile des Browsers und bestätigt mit der Eingabetaste. Betreibt man den ESP ohne Seriellen Monitor, kann man ihn im Router unter dem Namen "Du suchst mich" finden; dieser wurde im Code mit WiFi.hostname("Du suchst mich"); vergeben.

Wenn alles geklappt hat sollte jetzt die Startseite im Browser angezeigt werden. Mit den beiden Links "LED EIN" und "LED AUS" lässt sich die blaue Status LED ein- und ausschalten. Man kann aber auch direkt die entsprechende URL eingeben, in meinem Fall "192.168.178.76/led_ein" bzw. "192.168.178.76/led_aus".
Die Zeile "<meta name="viewport" content="width=300px">" im HTML-Quellcode sorgt dafür, dass auf dem Handy die Seite gezoomt angezeigt wird.


Statische IP-Adresse verwenden

Im oben gezeigten Code wird dem D1 über DHCP vom Router irgendeine freie IP-Adresse zugewiesen. Möchte man, dass sich der D1 am Router mit einer festen IP-Adresse anmeldet, so ist der Code wie folgt zu ergänzen.

Im Header, am besten direkt unter #include <ESP8266WiFi.h>, werden die drei Variablen local_IP, gateway und subnet deklariert und entsprechend der Router-Adresse befüllt. In meinem Fall besitzt der Router die Adresse 192.168.178.1, und ich hätte gerne die 192.168.178.15 für den D1 mini. Der Router wird diese Adresse jedoch nur dann zulassen, wenn sie nicht bereits durch ein anderes Gerät genutzt oder reserviert wird.

Vor der Zeile WiFi.begin(ssid, pwd); werden die Variablen dann mittels WiFi.config() übergeben. Eine fest vergebene IP-Adresse kann übrigens auch die Anmeldung am Router beschleunigen.


Einen Access-Point für WLAN-fähige Geräte bereitstellen

Der folgende Sketch macht prinzipiell dasselbe wie der oben gezeigte. Allerdings wählt sich der ESP8266 nicht ins Heimnetzwerk ein, sondern baut stattdessen einen eigenen Access Point auf. Über diesen kann man z.B. mit dem Handy auf den Webserver zugreifen und so die LED schalten.

Nachdem der Code kopiert und die beiden Variablen ssid und pwd angepasst wurden, öffnet man den Seriellen Monitor mit [Strg] + [Umschalt] + [M] und klickt anschließend auf "Hochladen" (bzw. verwendet die Tastenkombination [Strg] + [U]).

Ist der Sketch kompiliert und hochgeladen, startet der ESP8266 automatisch neu und baut einen Access Point mit dem Namen (SSID) "ESP8266_AccessPoint" auf. Wählt man sich nun mit dem Handy in dieses WLAN ein, kann über die IP-Adresse 192.168.1.1 die Startseite aufgerufen werden.

Die HTML-Seite lässt sich natürlich auch mittels HTML-Formatierung und durch hinzufügen von Java-Script etwas ansprechender gestalten.



HTML Authentifikation  (basic access authentication)

Möchte man den Zugriff auf den ESP8266 bzw. dessen Webserver beschränken, bietet sich eine einfache HTTP-Authentifizierung an. Dazu werden zunächst die Zugangsdaten in Konstanten hinterlegt, z.B. für den Benutzernamen http_UserName = "admin" und für das Passwort http_pwd = "1234".

Beim Aufruf der URL wird der Benutzer dann aufgefordert, sich mit diesen festgelegten Zugangsdaten anzumelden.



HTML-Code im Sketch

Wie in den vorangegangenen Beispielen zu sehen, wird der HTML-Code zunächst in eine Variable vom Typ String geschrieben und anschließend dem Webserver übergeben. Dabei kann es bei den Anführungszeichen zu Konflikten kommen, da sie sowohl innerhalb des HTML-Codes als auch zur Definition von Zeichenketten im Arduino-Sketch verwendet werden. Um dies zu vermeiden, gibt es drei Möglichkeiten:

  1. Wie in den Beispielen gezeigt per String html = R"***( <button class="button">Klick Mich</button> )***";
    • Der HTML-Code kann zwischen den Klammern unverändert eingegeben werden
  2. Im HTML-Code Hochkomma (') statt Anführungszeichen (") verwenden und normal zuweisen String html = "<button class='button'>Klick Mich</button>"
  3. Anführungszeichen mittels Backslash "\" maskieren String html = "<button class=\"button\">Klick Mich</button>"

Für Methode 3 hatte ich mal für einen anderen Zweck ein Tool geschrieben, dass die Maskierung mittels "\" automatisch vornimmt und auch wieder umkehren kann. Ebenso wird jede Zeile in Anführungszeichen gepackt, so, dass der HTML-Code direkt in den Sketch kopiert werden kann.

TE ESP HTML Convert (861 KB)



HTML-Datei im Flashspeicher

Wenn der HTML-Code umfangreicher wird, oder auch externe Dateien wie CSS, JavaScripts oder Bilder angezogen werden müssen, so empfiehlt sich  der interne Flashspeicher als Ablageort.
Wie man den Flashspeicher einrichtet und Dateien dahinein kopiert ist hier beschrieben. Sehr interessant ist hier ebenfalls ein FTP-Server für den Flashspeicher.
In den oben gezeigten Beispielen wird bei "Server.on" mittels "Server.send", der HTML-Code der Variable "html" an den Browser gesendet. Hier wird nun bei einer Browseranfrage (test.htm) die entsprechende HTML-Datei vom Flashspeicher an den Browser gesendet. Gleiches gilt auch für Bilder und sonstige Dateien.

Als Beispiel kann hier ein sehr einfaches Projekt mit WiFi + WebServer, inklusive der beiden Dateien "test.htm" und "bild.gif" heruntergeladen werden.

kompletter Quellcode inkl. Dateien (3 KB)



Flashspeicher - SPIFFS

Um Daten auf den das SPI (Serial Peripheral Interface) Flash File System ablegen zu können, muss der Flashspeicherbereich für das Dateisystem entsprechend formatiert werden. Dazu wählt man unter "Werkzeuge/Flash Size" eine passende Größe aus; beim Flashen des ESP wird dieser Bereich dann entsprechend formatiert.

Hinweis: Wird beim erneuten Beschreiben des ESP die Größe nicht verändert, so bleiben die im Dateisystem enthaltenen Dateien bestehen.

Um auf das File-System zugreifen zu können benötigt man #include "FS.h" und muss es im Setupbereich per SPIFFS.begin() starten. Hier mal ein kleines Beispiel zum Erstellen, Schreiben und Lesen einer Datei:


ESP 8266 Sketch Data Upload

Um Dateien in das Dateisystem (FS) laden zu können, benötigt man ein Plugin, z.B. "ESP8266FS" (ESP8266 Sketch Data Upload). Das Plugin wird nicht über die Bibliothekenverwaltung installiert, sondern muss manuell in das Installationsverzeichnis der Arduino-IDE kopiert werden. Das Plugin besteht aus einer einzelnen.jar-Datei, die in folgendes Verzeichnis kopiert werden muss:

Arduino\tools\ESP8266FS\tool

Das am Ende bereitgestellte Archiv enthält die beiden Unterordner "ESP8266FS\tool" bereits, und kann daher im Verzeichnis "Arduino\tools" direkt mit "Hierher entpacken..." entpackt werden.
Das Plugin erwartet im Sketch-Ordner den Unterordner "data" indem sich alle Dateien befinden die ins File-System des ESP hochgeladen werden sollen.

Der Upload wird dann über "Werkzeuge/ESP8266 Sketch Data Upload" angestoßen.

ESP8266FS.zip



FTP-Server für Flashspeicher

Um den Flash-Speicher bequem mit Daten befüllen und aktualisieren zu können kann man dem ESP einen einfachen FTP-Server verpassen. Ich nutze hierzu "PubSubClient" von Nick O'Leary. Dieser kann ganz normal über die Bibliotheken-Verwaltung installiert werden (Werkzeuge/Bibliotheken verwalten...)

Das Einbinden in den Sketch ist mit wenigen kurzen Zeilen Code erledigt

Anstelle von "user" und "password" darf selbstverständlich auch was sichereres angegeben werden. Mein gerne verwendeter FileZillar (v3.68.1) verbindet sich zwar problemlos mir dem ESP, bleibt dann aber um Upload mit der Meldung "Status: Verbindung hergestellt, warte auf Willkommensnachricht..." hängen und bricht dann mit "Fehler: Zeitüberschreitung der Verbindung nach 20 Sekunden Inaktivität" ab.
Beim Kramen in der Softwareschublade fand ich noch ein Relikt aus längst vergangenen Tagen, den WS-FTP v3.00 aus dem Jahre 1996 der auch unter Win10 und sicherlich auch noch unter Win11 anstandslos seinen Dienst tut und den ESP brav mit Daten versorgt - das is ja genau mein Ding, Software kann gar nicht alt genug sein.

Da man ihn heute wohl eher selten im Internet antreffen wird, stelle ich ihn hier mal zum Download bereit.

WS_FTP32 3.00 (137 kB)



MQTT

MQTT (Message Queuing Telemetry Transport) ist ein schlankes Nachrichtenprotokoll, mit dem Informationen innerhalb eines IoT-Netzwerks (Internet of Things) ausgetauscht werden können. Dabei dient ein Server, der hier Broker genannt wird, als Vermittler zwischen den einzelnen Geräten (Clients). Ein Gerät, das Daten empfangen soll, "subscribed" (abonniert) beim Broker ein bestimmtes Topic (Thema). Ein Gerät, das Daten senden soll, "published" (veröffentlicht) Informationen zusammen mit einem Topic an den Broker. Dieser leitet die Nachricht an alle Geräte weiter, die dieses Topic abonniert haben.

Ein Beispiel: Ein ESP8266 (Sensor) liest einen Fotowiderstand aus und übergibt die Information "Tag/Nacht" (z.B. 0 = Nacht, 1 = Tag) mit einem Topic, z.B. "Daemmerungsschalter", an den Broker. Der Broker leitet die Information an alle Clients weiter, die das Topic "Daemmerungsschalter" abonniert haben. PC und Handy können dann anzeigen, ob es Tag (1) oder Nacht (0) ist. Ein weiterer ESP8266 (Aktor), der dieses Topic ebenfalls abonniert hat, schaltet bei Nacht das Licht ein und am Tag wieder aus.

Wie das Beispiel zeigt, kann der ESP8266 sowohl als Subscriber (Empfänger) als auch als Publisher (Sender) arbeiten. Er kann aber auch beides gleichzeitig sein - Gleiches gilt natürlich auch für den PC und mobile Endgeräte. Genug Theorie, fangen wir an.

MQTT-Broker
Als Erstes benötigen wir einen Broker. Hier kann man entweder einen der zahlreichen Broker-Dienste im Netz in Anspruch nehmen oder selbst einen im Heimnetzwerk aufsetzen und betreiben. Vermutlich bin ich da einfach etwas altmodisch, aber die Daten auf einen Internet-Server hochzuladen, um sie dann fünf Meter weiter wieder herunterzuladen, fühlt sich irgendwie seltsam an. Deshalb läuft bei mir ein Raspberry Pi Zero W2, der im Betrieb gerade einmal etwa 1 Watt benötigt. Wie man die Himbeere aufsetzt und darauf den MQTT-Server Mosquito installiert ist hier zu finden. Wer keinen Raspberry hat kann Mosquito auch auf dem PC ausführen.

MQTT-Client
Um MQTT auf dem ESP8266 nutzen zu können benötigt man eine entsprechende Library, ich nutze hier die "PubSubClient" von Nick O'Leary. Diese sollte sich eigentlich so installieren lassen:

Bei mir hat die Suche jedoch nicht funktioniert, deshalb habe ich mir die Library als Zip bei Arduino.cc heruntergeladen und über "Sketch/Bibliothek einbinden/ZIP-Bibliotheken hinzufügen..." manuell installiert.


Daten an den Broker senden

Der folgende Sketch baut zunächst eine Verbindung zum heimischen Netzwerk auf und verbindet sich anschließend mit dem Broker. Danach beginnt der ESP8266 im 5-Sekunden-Takt die Nachricht "Nachricht xy" mit dem Topic "test1" an den Broker zu senden, wobei "xy" ein Zähler ist, der sich bei jedem Senden um 1 erhöht. Das Ganze dient als Demo bzw. als Grundgerüst für einen Sensoraufbau, bei dem anstelle von "Nachricht xy" die Zustände der Eingangspins übertragen werden.

Die WLAN-Initialisierung habe ich hier in eine eigene Sub-Routine ausgelagert, um den setup()-Bereich etwas übersichtlicher zu halten.

Retain Flag
Wird eine Nachricht mit gesetztem Retain-Flag gesendet, so wird sie einem MQTT-Client unmittelbar nach dessen Anmeldung zugestellt. Der Client muss also nicht warten, bis eine neue Nachricht eintrifft. Das ist z.B. dann sinnvoll, wenn ein Temperatursensor nur alle 15 Minuten einen Wert sendet, die Temperatur aber über eine Websocket-Verbindung direkt nach dem Aufruf der HTML-Seite zur Verfügung stehen soll. Hierzu wird bei client.publish() nach Topic und Nachricht noch der Parameter true für das Retain-Flag übergeben (siehe Bemerkung im Beispielcode).

Die gesendeten Informationen kann man mit TE MQTT Client am PC, oder mit dem IoT MQTT Panel auf dem Android Smartphone oder Tablet bestaunen.


Daten vom Broker empfangen

Der nächste Sketch zeigt ein Beispiel dafür, wie man MQTT-Nachrichten empfängt und darauf reagiert. Genauer gesagt abonniert der ESP8266 das Topic "test1". Sobald auf diesem Topic die Nachricht "ein" gesendet wird, schaltet er die blaue Status-LED ein. Wird "aus" gesendet, schaltet er sie wieder aus. Bei allen anderen Nachrichten wird der Inhalt lediglich im Seriellen Monitor ausgegeben, ohne dass weitere Aktionen ausgeführt werden.

Zum Senden von Nachrichten mit dem Topic "test1" kann ebenfalls der TE MQTT Client benutzt werden.


MQTT im Browser

In diesem Zusammenhang kann das Senden und Empfangen von MQTT Nachrichten im Browser ebenfalls interessant sein. Das hatte ich bereits im Zusammenhang mit dem Tasmota Stromzähler-Adapter (hier werkelt auch ein ESP6288 :-) beschrieben und ist hier zu finden. 



Deep-Sleep Mode

Der Tiefschlafmodus kann genutzt werden, um den Strombedarf des ESP8266 zu minimieren. Dabei erledigt der ESP seine Aufgaben und legt sich anschließend für eine vordefinierte Zeit schlafen. Nach dem Aufwachen nimmt er seine Arbeit wieder auf, erledigt diese und geht erneut in den Schlafmodus. Das Ganze eignet sich z.B. für Intervallmessungen im Batteriebetrieb. Der D1 mini benötigt im Betrieb (gemittelt inkl. WLAN) ca. 73 mA, im Deep-Sleep-Modus ca. 230 µA (beide Werte gemessen am 3,3-V-Einspeisepin).

Hierzu eine Abschätzung der Laufzeit im Batteriebetrieb:

Der D1 soll alle 15 Minuten einen Messwert erfassen (z.B. Temperatur oder Spannung) und diesen per WLAN versenden. Für das Erfassen und Senden benötigt er 5 Sekunden. Unter Berücksichtigung von Arbeits- und Deep-Sleep-Phase ergibt sich eine gemittelte Stromaufnahme von ca. 0,634 mA. Eine Batterie (3,3 V) mit 2500 mAh würde demnach etwa 3941,5 Stunden, also rund 164 Tage durchhalten.

Ein "nacktes" ESP-12E/F Modul benötigt im Deep-Sleep nur 18 μA (gemessen) und würde somit unter den gleichen Bedingungen auf 246 Tage kommen. Gleiches gilt für das ESP-01(S) Modul.

Tipp: Die Verwendung einer statischen IP-Adresse spart eventuell etwas Zeit beim Anmelden am Router, was wiederum die Arbeitszeitphase etwas verkürzt. Eine halbe Sekunde weniger Arbeitszeit bedeutet im obigen Beispiel gleich mal 12 Tage mehr Laufzeit :-)

Um mit den Werten ein wenig spielen zu können, hier mal ein OnlineRechner .


Code

Der Deep-Sleep-Modus kann prinzipiell an jeder beliebigen Stelle im Programmcode gestartet werden. Im folgenden Beispiel liegt der gesamte - natürlich hochkomplexe - Quellcode in void setup(), während void loop() leer bleibt. Nach getaner Arbeit wird der D1 dann mit ESP.deepSleep() schlafen geschickt. Die Deep-Sleep-Zeit wird dabei in Mikrosekunden angegeben.

Maximale Deep-Sleep-Zeit
Die maximale Deep-Sleep-Zeit wird zunächst durch die Begrenzung des zu übergebenden 32-Bit-Integer-Werts (-2.147.483.648 bis 2.147.483.647) eingeschränkt. Da ESP.deepSleep() jedoch nur positive Werte nutzt, steht effektiv der Bereich 0 bis 2.147.483.647 Mikrosekunden zur Verfügung. Das entspricht einer maximalen Schlafdauer von knapp 35 Minuten.

Verwendet man einen 32-Bit-Unsigned-Integer (0 bis 4.294.967.295), lässt sich dieser Wert ungefähr verdoppeln. Rechnerisch ergibt sich damit eine maximale Deep-Sleep-Zeit von rund 71 Minuten.

Stellt man auf einen 64-Bit-Integer um, wird die theoretisch mögliche Deep-Sleep-Zeit deutlich größer. In der Praxis wird jedoch ein Wert von gut 200 Minuten erreicht und nicht die rein rechnerisch möglichen 311 Minuten. Wer den exakten Wert für seine Konfiguration wissen möchte, kann sich diesen mit ESP.deepSleepMax() im Seriellen Monitor ausgeben lassen.

Hardware-Umbau

Lässt man den Code nun laufen, fällt der D1 zwar in den Deep-Sleep-Modus, wacht daraus aber nicht mehr von selbst auf. Damit er das tut, muss zunächst noch der Pin RST mit D0 (GPIO16) verbunden werden.

Nach Ablauf der vordefinierten Deep-Sleep-Zeit wird über D0 ein Reset ausgeführt und der Code im "void setup()" wird erneut gestartet.
Beim ESP-12E/F Modul muss die Brücke übrigens zwischen "RST" und "GPIO16" gelegt werden. Beim ESP-01(s) ist etwas diffizile Lötarbeit notwendig.



Sketch-Update über WLAN - OTA

Ist die physische Zugänglichkeit des ESP nicht oder nur erschwert gegeben, können Updates auch per WLAN eingespielt werden. Dazu muss jedoch OTA (Over The Air) auf dem betreffenden ESP zuvor eingerichtet sein.

Zunächst muss ein Teil des Flashspeichers für OTA zur Verfügung gestellt werden. Wie beim Einrichten von SPIFFS geschieht dies über den Menüpunkt "Werkzeuge / Flash Size: …". Dabei ist darauf zu achten, dass der OTA‑Bereich mindestens die Größe der einzuspielenden .bin‑Datei hat, aber auch noch genügend Platz für den Sketch und gegebenenfalls für SPIFFS lässt.

Dann muss natürlich noch etwas gecodet werden, Im folgenden Plug-in-Codebeispiel wird vorausgesetzt, dass WiFi und der Webserver bereits konfiguriert sind.

Zum Updaten wird der Sketch in Binärcode benötigt, diesen erhalten wir über den Menüpunkt "Sketch/Kompilierte Binärdatei exportieren" oder über [Strg] + [Alt] + [S].

Im Sketch-Ordner wird nun eine.bin‑Datei erzeugt, die dann im Dateidialog der OTA‑Update‑Seite „verfüttert“ werden kann.


Die Option Drucken funktioniert erst ab Netscape V4.0 bzw. I-Explorer 5.0 !
[erstellt 26.04.2024 - letzte Aktualisierung 26.01.2025]