ESP8266-01 WLAN-Modul mit dem Arduino UNO programmieren

  • 0

ESP8266-01 WLAN-Modul mit dem Arduino UNO programmieren

Kategorien:

Arduino

ESP8266-01

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 dem ESP8266-01, den wir in diesem Tutorial mit einem Arduino UNO programmieren wollen.

 

Software und nötige Treiber installieren

Als erstes benötigen wir eine Arduino-IDE (Download: https://www.arduino.cc/en/Main/Software) 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„.

ESP8266_Voreinstellungsfenster

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.

ESP8266_Werkzeuge

Zum Vergrößern Bild anklicken

 

ESP8266_esp8266

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.

ESP8266_Werkzeuge_Generic_ESP8266

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-01-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, oder einen AMS1117 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) 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.

LM317_3.3V_Schaltplan

Zum Vergrößern Bild anklicken

 

Pins des ESP8266-01

Hinweis: Alle GPIO-Pins, so wie TX und RX haben einen internen PullUp-Widerstand, sind also generell auf HIGH gezogen.

Fallstrick Nummer 2: Ganz wichtig ist, dass GPIOo und GPIO2 steuern, wie das Modul starten soll und erfordern daher eine besondere Handhabung.

ESP8266BootOptions

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-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
CS Chip Select kommt fest auf die 3,3V Versorgungsspannung
TX geht zu TX (Pin 1 des Arduinos)
RX geht 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.

ESP8266_PINOUT

 

Unsere Schaltung schaut dann wie auf dem unten folgenden Bild 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.

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.

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.

 

ESP8266-01_programmieren_Steckplatine

Zum Vergrößern Bild anklicken

 

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

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.

 

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:

warning: espcomm_sync failed
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.


Schreibe einen Kommentar

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.