Das ESP8266-WLAN-Modul ist in seinen verschiedenen Varianten sehr kostengünstig und wird bereits mit einer AT-Befehlssatz-Firmware vorprogrammiert ausgeliefert, was bedeutet, dass sich diese Module sehr einfach an einen Mikrocontroller wie beispielsweise dem Arduino anschließen lassen und den Arduino um eine WLAN-Funktionalität erweitern, wie es andere WLAN-Shields zwar auch tun, aber das wesentlich teurer.
Diese Module sind sehr leistungsstark, sind gut verarbeitet und verfügen auch über einen eigenen Speicher, was es ermöglicht, Sensoren oder andere INPUTS/OUTPUTS an den vorhandenen GPIOs zu verarbeiten.
Man kann die ESP8266-Module auch vollständig ohne einen Arduino betreiben, da sie über einen eigenen Mikroprozessor (L106 32-bit RISC Mikroprozessorkern, basierend auf dem Tensilica Xtensa Diamond Standard 106Micro mit 80 MHz) verfügen, der sich genau so einfach mittels der Arduino-IDE programmieren lässt wie ein Arduino Mikrocontroller.
Somit lässt sich eine WLAN-Funktionalität auf einfache Weise in ein eigenes Arduino-Projekt einfügen.
Wir beginnen mit den ESP8266 ESP-01 [1] und ESP-01S [2], die wir in diesem Tutorial mit einem Arduino UNO programmieren wollen.
Im Grunde verhalten sich die beiden gleich, nur beim programmieren unterscheidet sich der Aufbau der elektronischen Schaltung ein klein wenig.
Software und nötige Treiber installieren
Als erstes benötigen wir eine Arduino-IDE (Download: https://www.arduino.cc/en/Main/Software [3]) auf unserem Rechner.
Falls bereits eine Version installiert ist, sollte diese mindestens in der Version 1.6.4 vorliegen, sonst funktionieren die notwendigen ESP-Treiber nicht.
Um nun die notwendigen Treiber zu installieren, öffnen wir im Programmmenü “Datei” den Punkt “Voreinstellungen“.
[4]
[5]Zum Vergrößern Bild anklicken
In dem sich darauf öffnenden Fenster tragen wir die folgende URL “http://arduino.esp8266.com/stable/package_esp8266com_index.json” unter “Zusätzliche Boardverwalter-URLS” ein.
Befindet sich in dem Eingabefeld bereits ein Eintrag, so kann man den neuen Eintrag mit einem Komma nach dem letzten Eintrag einfach hinzufügen.
Das Fenster schließen wir jetzt durch anklicken des “OK“-Buttons.
Nach der Installation scrollen wir unter dem Menüpunkt “Werkzeuge“->”Board” nach oben bis zu der Auswahl “Boardverwalter“.
In dem sich öffnenden Fenster suchen wir den Eintrag “esp8266” und installieren das entsprechende Paket.
[6]Zum Vergrößern Bild anklicken
[7]Zum Vergrößern Bild anklicken
Danach stehen uns unter “Werkzeuge“->”Board” am unteren Auswahlende etliche neue Boards zur Verfügung. Unter anderem den Eintrag “Generic ESP8266 Module”.
Diesen Eintrag wählen wir aus und dann haben wir alles, um unser ESP-Modul programmieren zu können.
[8]Zum Vergrößern Bild anklicken
Hardwareaufbau
Achtung: Es gibt ab jetzt ein paar Fallstricke, daher lest den folgenden Teil aufmerksam und Ihr werdet Euer ESP-Modul mühelos und ohne Fehlerausgaben sauber mit dem Arduino programmieren.
Fallstrick Nummer 1: Das ESP8266 ESP-01(S)-Modul läuft NUR mit 3.3V (max. 3.6V – auch die GPIO´s sind nicht 5V tolerant!).
Alles darüber zerstört das Modul! Der Arduino hat zwar einen 3.3V-Ausgangspin, aber der liefert je nach Arduino-Clon möglicherweise nicht genug Spannung.
Daher sollte man auf jeden Fall besser eine externe Stromquelle verwenden und diese auf maximal 3.3V Output einstellen.
Dafür nimmt man beispielsweise einen LM317 [9], oder einen AMS1117 [10] für 3.3V Ausgangsspannung.
Wichtig ist, dass der verwendete Spanungswandler/Step-Up/Step-Down mindestens 500mA Strom, noch besser mindestens 800mA – bei 3.3V zur Verfügung stellen kann, sonst kommt es – auch später im Livebetrieb – möglicherweise zu einem ominösen Verhalten des ESPs in Form von Reboots, usw.
Wir verwenden für diesen Aufbau einen LM317 Linearregler (beachtet die Pinbelegung des LM317. Datenblatt [11]) und dafür brauchen wir noch zwei Widerstände, um die Spannung sauber herunterzuregeln.
Wir brauchen einen 220 Ohm Widerstand und einen 330 Ohm Widerstand. Mit diesem kleinen Schaltkreis erhalten wir rund 3.1V bei einer Eingangsspannung von 5-12 VDC (geht auch mehr, aber dann müsste man den LM317 besser kühlen).
Optional noch eine Freilaufdiode (D1) zwischen Ein- und Ausgang des LM317 als Schutz einbauen.
[12]Zum Vergrößern Bild anklicken
Pins des ESP8266 ESP-01(S)
Hinweis für den ESP-01S: Alle GPIO-Pins, so wie TX und RX haben einen internen PullUp-Widerstand, sind also generell auf HIGH gezogen.
Die normale Version ESP-01 hat dies nicht. Also brauchen wir in unserer Schaltung entsprechende Widerstände.
Fallstrick Nummer 2: Ganz wichtig ist, dass GPIOo und GPIO2 steuern, wie das Modul starten soll und erfordern daher eine besondere Handhabung.
[13]Zum Vergrößern Bild anklicken
Wie in der Tabelle zu sehen ist, muss GPIO0 auf LOW und GPIO2 auf HIGH gezogen werden, um das Modul programmieren/flashen zu können.
Verwenden wir dagegen unser Modul mit dem fertigen Programm, so muss GPIO0 und GPIO2 auf HIGH gezogen werden.
Diese beiden Möglichkeiten beziehen sich nur auf den kurzen Bootvorgang (oder nach einem Reset).
Danach können die GPIOs ganz normal verwendet werden und jeden anderen Status annehmen.
GPIO15 ist hier nicht von Interesse, da das ESP8266-01-Modul keinen herausgeführten GPIO15-Pin hat.
Die Pinbelegung des ESP8266 ESP-01 für den Flashvorgang sieht dann wie folgt aus:
VCC kommt an 3,3V extra Versorgungsspannung
RST (Reset) bleibt offen – vor dem Programmieren kurz auf GND legen
CHPD/EN/CS Chip Select kommt fest mit einem 1 KOhm Widerstand auf die 3,3V Versorgungsspannung
TX geht zu TX (Pin 1 des Arduinos)
RX geht über einen Levelshifter (3,3V) zu RX (Pin 0 des Arduinos)
GPIO 0 geht mit einem 2-10 KOhm Widerstand an GND zum Programmieren (Nur kurz anlegen!)
GPIO 2 bleibt offen
GND geht an Masse Versorgungsspannung
GND des Arduinos geht auf die gemeinsame Masse.
Der ESP-01S ist identisch, bis auf CHPD/EN/CS und GPIo. Hier brauchen wir keine Widerstände. Siehe Schaltplan.
[14]
Unsere Schaltung schaut dann wie auf den unten folgenden Bildern aus.
Links ist unser Linearregler, der auf der obigen Stromschiene eine Spannung von 5-12V INPUT in rund 3.1V runterregelt und diese 3.1V OUTPUT auf der unteren Stromschiene zur Verfügung stellt.
ESP-01: Bevor wir Strom auf das Breadboard schalten, muss der blaue Draht (GPIO0) mit “** INFO” mit einem PullDown-Widerstand zwischen 2-10KOhm auf LOW gezogen werden.
ESP-01S: Der blaue Draht wird nur kurz auf LOW gezogen.
Wir schalten den Strom ein und dann entfernen wir das blaue Kabel wieder, bevor wir anfangen das Modul zu programmieren.
Warum das so ist, ist im folgenden Fallstrick erklärt.
Schaltplan ESP-01:
[15]
Schaltplan ESP-01S:
[16]Fallstrick Nummer 3: Will man GPIO0 als Ausgabe-Pin verwenden und setzt GPIO0 in seinem Programm auf HIGH – obwohl zum programmieren der GPIO0 ja auf LOW gezogen sein muss, kann die Erdung den ESP8266-Chip möglicherweise zerstören!
Daher ist der sicherste Weg, den ESP8266-01 wie folgt zu programmieren. Damit geht man den sicheren Weg, auch wenn er etwas “komplexer” zu sein scheint. Er hat aber den Vorteil, dass das Modul vor der Zerstörung geschützt wird.
1.) Zuerst schalten wir alles stromlos,
2.) dann verbinden wir mit dem PullDown-Widerstand GPIO0 mit GND. (Blaues Kabel)
3.) Wir verbinden das Modul mit dem Strom und lassen es kurz hochbooten. Das Modul geht in den Programmiermodus.
4.) Wir entfernen die GPIO0-Leitung (blaues Kabel) und
5.) programmieren das Modul neu.
Somit verhindern wir, dass der Ausgabepin kurzgeschlossen wird, wenn das Programm nach dem erfolgreichen hochladen anfängt zu laufen.
Jetzt können wir, nachdem wir alles stromlos geschaltet haben, den GPIO0-Pin mit LED/Relais, oder was auch sonst immer verbinden.
Programmieren des ESP8266-01
In der Arduino IDE muss nun unter “Werkzeuge“->”Board” das “Generic ESP8266” ausgewählt und die richtige COM Schnittstelle für den Arduino eingestellt werden mit 115200 Baud. (Nur diese Geschwindigkeit funktioniert)
[17]
Jetzt flashen wir das ESP-Modul mit dem Testprogramm “Blink”, wie wir es auch vom Arduino her kennen. (“Hello World” für Elektroniker 🙂 )
Wichtig ist, dass wir jetzt, bevor wir mit dem “Hochladen” beginnen,
zuerst GPIO0 mit dem PullDown auf GND ziehen (Punkt 2),
dann das freie Kabel, das am Reset-Pin des Moduls hängt, ganz kurz in GND stecken – es sollte dabei ganz kurz die blaue LED aufleuchten. – und wieder herausziehen und
abschießend das GPIO0-Kabel wieder abziehen (Punkt 4).
Unser Modul ist nun bereit, das neue Programm zu empfangen. Wir wählen “Hochladen” aus, lassen den/das (???) Sketch kompilieren und wenn alles erfolgreich ist, wird der Sketch auch anschließend fehlerfrei hochgeladen.
ESP-01: Wichtig, wenn Ihr nicht die S-Version verwendet, müsst Ihr den folgenden Sketch verwenden und nicht den Beispielsketch, der in der Arduino vorhanden ist. Der Grund ist nämlich der, das bei diesen Modulen die blaue LED auf der Platine mit dem GPIO1 verbunden ist. Bei dem S-Modul haben sie das geändert.
ESP-01S: Verwendet einfach den Beispielsketch “Blink” zu finden unter “Datei“->”Beispiele“->”ESP8266”
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/* ESP8266 Blink by Simon Peter Blink the blue LED on the ESP-01 module This example code is in the public domain The blue LED on the ESP-01 module is connected to GPIO1 (which is also the TXD pin; so we cannot use Serial.print() at the same time) */ int LED=1; // GPIO1 = blaue LED void setup() { pinMode(LED, OUTPUT); // Initialize the LED_BUILTIN pin as an output } // the loop function runs over and over again forever void loop() { digitalWrite(LED, LOW); // Turn the LED on (Note that LOW is the voltage level // but actually the LED is on; this is because // it is acive low on the ESP-01) delay(1000); // Wait for a second digitalWrite(LED, HIGH); // Turn the LED off by making the voltage HIGH delay(2000); // Wait for two seconds (to demonstrate the active low LED) } |
Vergessen wir das resetten vor dem flashen, oder haben den GPIO0 nicht mit dem Pulldown-Widerstand auf LOW gezogen gehabt, erhalten wir diese Fehlermeldung der Arduino-IDE:
error: espcomm_open failed
Wenn aber alles geklappt hat, blinkt nun die blaue LED des ESP-Moduls.
Jetzt beenden wir den Flash-Modus des ESP-Moduls. (GPIO0 darf nicht mit GND verbunden sein.)
Dazu resetten wir mit dem freien Reset-Kabel nochmal, in dem wir das Kabel kurz in GND stecken.
Das ESP-Modul startet neu und nun blinkt die blaue LED wie vorher auch.
Fallstrick Nummer 4: Wird der Arduino abgeschaltet und stecken RX und TX noch im Board und ist dieser noch mit GND verbunden, startet das ESP-Modul auch nicht, da RX und TX auf GND, also LOW gezogen werden, was nicht sein darf.
Daher unbedingt das GND-Kabel abziehen, das den Arduino mit dem Breadboard verbindet.
Ich wünsche Euch viel Spaß und viel Erfolg.
Nachtrag vom 26.10.2019: Wir bieten jetzt einen günstigen ESP-Programmer [18] in unserem Shop an, der es einem wesentlich erleichtert, ESP-01er-Module zu flashen.
Wir haben den ESP-Programmer ausprobiert und ihn auf Herz und Nieren untersucht. Das Ergebnis könnt Ihr hier nachlesen: “Modul mit dem ESP-Programmer programmieren [19]”