Arduino goes ESP8266

Inhaltsverzeichnis

WiFi-Shields für den Arduino waren bis vor gar nicht allzu langer Zeit nur eines, nämlich teuer. Dann kam im August 2014 der WiFi-Chip ESP8266 des chinesischen OEM-Herstellers Expressif zusammen mit einem kompletten TCP/IP-Stack auf dem Markt. Die Integration des Arduino ins WLAN mit dem ESP8266 ist Gegenstand der vorliegenden und der nächsten Folge.

Der ESP8266 der in Shanghai ansässigen Firma espressif implementiert die WiFi-Standards IEEE 802.11 b/g/n. AI-Thinker, ein weiteres Unternehmen, begann schon Ende 2014 damit, den Chip als Basis für Boards wie dem ESP-01 zu verwenden, das es für nur wenig Geld zu kaufen gibt. Seitdem ist es möglich, ein Arduino-Board für eine Handvoll Dollars (ab 2 bis 3 €/US-$) mit WiFi auszurüsten. Was steckt hinter dem preisgünstigen Baustein?

Der ESP8266-Chip enthält eine 32-Bit CPU Tensilica Xtensa LX106 mit 80 MHz Taktfrequenz, 64 KByte Programmspeicher und 96 KByte Datenspeicher sowie einen Flashspeicher von 512 KByte bis 4 MBytes. Auch die anderen Leistungsdaten machen einen sehr passablen Eindruck:

• Bis zu 16 GPIO-Anschlüsse (GPIO = General Purpose IO)
• SPI- und I²C-Bus
• I²S-Bus für PCM-Audio-Kommunikation, der keine Verwandtschaft mit dem I²C aufweist.
• UART für Duplex-Betrieb, einen für reines Senden
• 10-Bit-Analog-/Digitalwandler

Diese Leistungsdaten übertreffen in einigen Aspekten die eines Arduino Uno oder Mega. Daher haben Entwickler inzwischen Unterstützung für die Boards in die Arduino-IDE integriert. Ein ESP8266-Board lässt sich dadurch als eigenständiges Entwicklungsboard nutzen, worauf ich später noch eingehe. Das ist nicht zuletzt dem Espressif SDK für den ESP8266 zu verdanken. Tatsächlich gibt es das SDK in zwei Ausprägungen, einer für Echtzeitzugriffe und einer anderen für reaktives Programmieren. Insofern lohnt sich der Blick auf die Entwicklerseiten von espressif. Zusätzlich existieren alternative SDKs wie das esp-open-sdk.

Das preisgünstige ESP-01-Board hat inzwischen großen Zuwachs bekommen. Die Boards sind jetzt von ESP-01 bis ESP-14 nummeriert. Daneben bieten zahlreiche Hersteller eigene Boards an, etwa SparkFun, Adafruit, Olimex oder WeMos.

Bekannt als Open-Source-IoT-Plattform ist das Board NodeMCU, das die Schriftsprache Lua per Firmware unterstützt und dabei auf der ESP8266 SDK aufsetzt. Der Hardware liegt übrigens ein ESP-12-Board zugrunde (ESP-12E oder neuer ESP-12F).

Herausforderung Logic Level

Die Symbiose zwischen Arduino und ESP-Boards verspricht ein ideales und vor allem preisgünstiges IoT-System. Insoweit steht einer Heirat finanziell nichts im Weg. Allerdings gibt es eine technische Hürde. Wie wir wissen, funktionieren viele Arduino Boards mit 5-V-Logik. Der ESP8266 und die darauf basierenden Boards arbeiten allerdings mit 3,3 V. Was nun?

Im Internet gibt es die abenteuerlichsten Vorschläge, wie Nutzer damit umgehen sollten, z.B.:

• Antipattern 1: Ignorieren der verschiedenen Spannungen. Das ESP8266-Board bekommt also eine direkte Verbindung zu der 5-V-Logik des Arduino. Mag sein, dass dies sogar für kurze Zeit klappt. Auf Dauer ist es ein teurer Spaß.
• Antipattern 2: Anschluss des ESP-Boards an den 3,3-V-Ausgang des Arduino. Auch das kann sporadisch funktionieren. An der Tatsache, dass der Arduino-3,3-V-Ausgang wesentlich weniger Leistung zur Verfügung stellt als der ESP8266 benötigt, führt es allerdings nicht vorbei. Deshalb dürfte hier nicht viel Freude aufkommen.

Bleiben drei Varianten. Zum einen lässt sich ein Spannungsteiler aus Widerständen konstruieren: Wichtig dabei ist vor allem, dass wir keinen 5-V-Ausgang des Arduino mit einem 3,3-V-Eingang des ESP8266 verbinden und damit das ESP-Board unweigerlich "braten".

5-V-Signale des Arduino (z.B. Tx) zerlegt man per Spannungsteiler in zwei Komponenten mit 1,7 V und 3,3 V (siehe Abbildung) und führt die 3,3 V an den Eingang des ESP8266 (z.B. Rx).

Was die Toleranz von Signalen betrifft, ist der Arduino relativ gutmütig. Alles was über 3 V liegt, zählt als HIGH (1), und alles was unter 1,5 V liegt, als LOW (0). Legt man ein HIGH-Signal des ESP8266, also 3,3 V, an einen 5-V-Eingang des Arduino, ist das unproblematisch, zumindest theoretisch. Großer Spielraum zwischen 3,3 V und 3 V ist in der Praxis damit nicht vorhanden. Schon bei geringfügigen Störungen könnte es zu Ärgernissen kommen. Diese Variante schützt zwar vor Kollateralschäden, kann aber zu häufigen Übertragungsfehlern führen. Ein weiterer Nachteil eines Spannungsteilers ist sein höherer Energieverbrauch gegenüber der nachfolgenden Option.

Wer auf Nummer sicher gehen will, besorgt sich einen Logic-Level-Konverter bzw. Logic-Level-Shifter mit 5 V auf der einen und 3,3 V auf der anderen Seite. Damit funktionieren beide Richtungen der Signalkonvertierung. Die meisten Produkte bieten dafür mehrere Kanäle. Hier ist man in jeder Hinsicht auf der sicheren Seite.

An die 5-V-Seite des Logic-Level-Shifters sind 5 V und GND des Arduino Uno/Mega anzulegen. Die RX und TX-Ports (Serial1 beim Mega oder SoftwareSerial beim Uno) schließt man an zwei Kanäle des Logic-Level-Konverters an. An die 3,3-V-Ports des Logic-Level-Konverters kommen entsprechend 3,3 V und GND des ESP8266 sowie dessen RX-/TX-Anschlüsse. Bitte beachten Sie, dass RX-Eingang des Arduino über den Logic-Level-Konverter mit dem TX-Ausgang des ESP8266 verbunden werden muss und der TX-Ausgang des Arduino über Logic-Level-Konverter mit dem RX-Eingang des ESP8266. Es reicht daher ein Logic-Level-Shifter mit vier Kanälen.

Variante 3 wäre übrigens, einfach ein Arduino-Board mit 3,3 V zu verwenden. Dazu gehören beispielsweise der Genuino/Arduino 101 und der Genuino/Arduino Due. Allerdings laufen einige Arduino-Bibliotheken wegen dessen Hardwarebesonderheiten nicht auf dem Due, weshalb der Spaß sich dort in engen Grenzen hält.

Arduino Mega oder Arduino Uno

Es gibt noch eine schlechte Nachricht. Nicht jedes ESP-01-Board harmoniert gut mit dem Uno. Der Arduino Uno als berufsmäßiger Minimalist besitzt nur einen seriellen Kommunikationskanal mit RX (Receive) und TX (Transmit). Für die Zusammenarbeit mit dem ESP-01 sind aber zwei serielle Kanäle nötig. Eine für die Arbeit mit dem seriellen Monitor, eine andere für die Kommunikation zwischen Arduino und ESP-Board. Es gibt als Ausweg einen seriellen Software-Port.

#include <SoftwareSerial.h> // Simulierter serieller Port
#define ESP_RX   2
#define ESP_TX   3
SoftwareSerial Serial1(ESP_RX, ESP_TX);

Der funktioniert aber nicht immer. Bei höheren Baud-Raten kommt der "virtuelle" serielle Port schlichtweg nicht mehr mit. Zum Glück tritt das Problem bei neueren ESP-01-Boards fast nicht mehr auf, die von vornherein auf 9600 Baud eingestellt sind. Zumindest hatte ich bislang keine Probleme.

Empfehlenswert ist an dieser Stelle der Arduino Mega 2560, der nicht nur wesentlich besser bestückt ist, was serielle Wege betrifft, sondern generell mehr Pins besitzt. Noch dazu passen fast alle Uno-kompatiblen Shields auch auf den Mega. Zu erwerben ist das Board für 9 Euro aus China sowie ab rund 12 Euro von deutschen Händlern. Es enthält vier serielle Ports, was für die meisten Einsatzgebiete ausreichen sollte.

Die Anschlüsse von Arduino über Logic Level Konverter zu Arduino Mega sind wie folgt:

ESP-01          Logic Level  Shifter        Arduino Mega
                ---------------------
Vcc(3.3V) ----  |Vcc(3.3V)     Vcc(5V)| ----  Vcc(5V)
URX      ----   |CH1L               CH1H | ----  TX1
TRX      ----   |CH2L           CH2H  | ----  RX1   
GND      ----   |GND            GND  | ----  GND
                 ---------------------

Zudem sind zu belegen:

CH_PD  auf 3.3V => Pin zum Programmieren des Boards
RST    auf 3.3V => Pin zum Reset
GPIO00 auf 3.3V => General Purpose IO Pin 0
GPIO01 auf 3.3V => General Purpose IO Pin 1

Für die Stromversorgung des ESP-01 empfiehlt sich eine separate 3,3-V-Spannungsquelle, am besten ein sogenanntes FTDI-Breakout-Board mit USB-Port und Jumper für Umstellung zwischen 3,3 V und 5 V. Diese Art von Breakout-Boards hatten wir auch schon für unseren selbstgebauten Arduino verwendet (=> Beitrag über den iXduino), um zum einen Sketche laden zu können und das Board zum anderen mit Strom zu versorgen.

Das mag zwar etwas übertrieben anmuten, aber später lernen wir noch eine andere Persönlichkeit des ESP8266 kennen. Die ESP8266-Boards lassen sich nämlich als eigenständige Controllerboards über die Arduino IDE nutzen.

Relay-Station

Wenn alles geklappt hat, müsste das rote LED des ESP-01-Boards leuchten. Bei Inbetriebnahme flackert auch kurz die blaues LED links neben der roten. Damit signalisiert das ESP-Board Betriebsbereitschaft.

Um tatsächlich mit dem ESP8266 zu kommunizieren, brauchen wir einen Sketch. Ich gehe davon aus, dass Sie einen Mega und Anschluss des ESP-Boards an den seriellen Port 1 des Mega benutzen (Pins RX1,TX1). Damit meine ich natürlich nicht den direkten Anschluss, sondern den indirekten über den Logic-Level-Shifter.

void setup()
{
    Serial.begin(9600);
    Serial1.begin(115200);
}
void loop()
{
    while (Serial1.available()) {
        Serial.write(Serial1.read());
    }
    while (Serial.available()) {
        Serial1.write(Serial.read());
    }
}

Was sich in dem Sketch abspielt, ist schnell erzählt. Der Mega kommuniziert mit dem ESP-01 über Serial1 und über USB mit dem seriellen Monitor (Serial). Bekommen Sie Kauderwelsch am seriellen Monitor, ändern Sie die Baudrate auf den im Sketch eingestellten Wert. Sehen Sie ein wenig Buchstabensalat und danach sinnvollen Text, ist die Welt in Ordnung.

Der Sketch liest (in der ersten while-Schleife) die Daten von Serial1 (ESP-Board) und schreibt Sie auf Serial (serieller Monitor). Dadurch können Sie die serielle Ausgabe lesen. In der zweiten while-Schleife liest der Sketch, was Sie im seriellen Monitor in der oberen Textbox eingeben (Serial), und leitet es an den ESP8266 weiter (über Serial1). Dazu ist es wichtig, in der halbrechten Auswahlbox (links neben der für die Baudrate) Both NL & CR einzustellen.

• Geben Sie jetzt AT ein, erhalten Sie als Antwort OK.
• Bei Eingabe von AT+GMR, meldet der ESP8266 Versionsinformation zurück.
• AT+RST führt zum Reset des ESP8266.
• AT+CWLAP meldet die Liste gefundenen WLAN Access Points.

    AT+CWLAP
 
     +CWLAP:(4,"KD-WLAN-C1A1",-92,"44:32:c8:9b:af:5a",1,-24)
     +CWLAP:(3,"StalWLAN",-58,"08:96:d7:95:b2:ca",7,-1)
     ...
    OK

• Mit AT+CWJAP_DEF="SSID","PASSWORD" bauen Sie eine Verbindung zum gewünschten WLAN Access Point auf. Ich habe die Variante mit Suffix _DEF verwendet, bei der sich der ESP8266 die Zugriffsdaten im Flash merkt.
• Mit AT+CIFSR erfahren Sie IP und MAC-Adresse ihres ESP8266-Boards.

    AT+CIFSR
 
     +CIFSR:STAIP,"192.168.178.101"
     +CIFSR:STAMAC,"5c:cf:7f:0f:a8:74"
 
    OK

Eine komplette Liste der AT-Kommandos finden Sie beispielsweise bei sparkfun.

Bislang haben wir das ESP8266-Boards als Client betrieben (STA = Station). Grundsätzlich lässt es sich auch als Access Point (AP) einsetzen, um zum Beispiel ein lokales Mesh-Netzwerk verschiedener Boards aufzubauen. Diese beiden Rollen kann der ESP8266 auch gleichzeitig einnehmen (STA+AP).

ESP8266 als eigenständiges Board benutzen

Es gibt inzwischen Software, um ein ESP8266-Board in der Arduino IDE als eigenständiges Board zu verwenden. Als Schnittstelle zum ESP-01 brauchen wir das bereits erwähnte FTDI-Breakout-Board. Zunächst müssen wir das ESP-01 Modul mit dem FTDI-Board verbinden.

Zu verbinden sind:

GND   (ESP-01) mit GND (FTDI)
GPIO0 (ESP-01) mit GND (FTDI)
RX    (ESP-01) mit TX  (FTDI)
TX    (ESP-01) mit RX  (FTDI)
CH_PD (ESP-01) mit Vcc (FTDI)
Vcc   (ESP-01) mit Vcc (FTDI)   

Stellen Sie vor dem Anschluss an den Computer sicher, dass Sie den Jumper des FTDI-Boards auf 3,3 V eingestellt haben. Nun schließen Sie das FTDI-Board über USB-Kabel an Ihren Computer an. Die rote Onboard-LED des ESP-01 sollte nun leuchten.

Sie könnten sich jetzt mit einem Terminal-Programm wie putty (Windows) oder ssh (OS X, Linux) über den seriellen Port direkt mit dem ESP8266-Board verbinden, um dort das Modul über AT-Kommandos anzusteuern.

Danach brauchen wir einen Boardmanager, um den ESP-01 über die Arduino IDE ansprechen zu können. Dazu gehen Sie in die Arduino IDE und dort ins Menü Preferences. Sie finden im unteren Teil des Fensters eine Textbox mit dem Titel "Additional Boards Manager URLs". Dort geben Sie Folgendes ein:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Danach können Sie im Tools-Menü unter Boards das verwendete ESP8266-Board eingeben sowie den Port, an dem sich der FTDI-Adapter befindet. Damit können Sie das Board nutzen wie ein Arduino-Board - nur im Übersetzer-Backend arbeiten andere Tools. Das bleibt aber für Entwickler transparent.

Im Menü File | Examples | ESP8266 gibt es das Programm Blink, das Sie nun auf das Board laden können, um die Konfiguration zu testen. Während das Programm auf das Board geladen wird, sehen Sie etwa Folgendes im Sketchfenster:

Hinter den Kulissen haben Sie dadurch auf den ESP8266 eine neue Firmware geladen. Wie Sie eines Tages zur AT-Firmware zurückkehren können, besprechen wir gleich.

Flasher

Sofern Sie eines Tages die Firmware Ihres ESP-01 upgraden oder austauschen wollen, benötigen Sie einen Flasher. arum Sie das eventuell tun sollten? Vielleicht wollen Sie eine neuere oder eine alternative Version der Firmware installieren. Im Internet existieren dafür eine Vielzahl unterschiedlicher Optionen.

Außerdem haben Sie bereits neue Firmware auf das ESP8266-Board aufgespielt, ohne es zu wissen. Zumindest, wenn Sie die Arduino IDE zum Programmieren von Sketchen für Ihr ESP-Board verwendet haben, wie oben beschrieben. Jedes hochgeladene Arduino-Programm endet als Firmware auf dem ESP-Board.

Hier eine kleine Auswahl:

• Vom Hersteller Espressif gibt es entsprechende Tools und SDKs. Der Flasher funktioniert unter Windows.
• Das Werkzeug esptool.py basiert auf Python und unterstützt Linux, Mac OSX und Windows.
• Das Werkzeug esptool.ck läuft unter Linux und Windows.

Standardmäßig ist auf den ESP-Boards von AI-Thinker eine AT-Firmware installiert. Das ist die Software, die wir in Zusammenhang mit den AT-Befehlscodes kennen gelernt haben. Das Nodemcu-Board (auf Grundlage des ESP-12E) hat eine Lua-Umgebung. ESPEasy konvertiert ein ESP-Board (bevorzugt ESP-12E) in eine Sensorsteuerung für die Heimautomatisierung.

Bevor Sie eine neue Firmware auf ein ESP8266-Board aufspielen können, müssen Sie zuvor a) den GPIO0-Port des Boards mit GND verbinden und b) einen RESET des Boards durchführen. Letzteres können Sie beispielsweise erreichen, indem Sie das Board kurzzeitig vom Spannungseingang trennen. Um das bequemer zu gestalten, könnten Sie die GPIO0- und RST-Pins des Boards über Schalter steuern. In der Abbildung von dieser Webseite bekommen Sie nähere Details, wie die Flash-Hardwareumgebung aussehen sollte. Auf derselben Webseite erhalten Sie ausführliche Informationen zum Espressi-Flash-Tool für Windows.

Achtung: Es gibt ESP-Boards mit unterschiedlichen Leitungsmerkmalen, zum Beispiel unterschiedlich dimensionierte Flashspeicher mit 512 KByte, 1 MByte, 4 MByte, die üblicherweise in zwei Hälften aufgeteilt sind: 2 x 256 KByte, 2 x 512 KByte, 2 x 1 MByte, 2 x 2 MByte. Beim Flashen gibt es die sogenannte "flash size" zu beachten, etwa 2 Mbit, 4 Mbit, 8 Mbit, 16 MBit oder 32 Mbit.

• Die blauen ESP-01 Boards integrieren 512 KByte Flashspeicher und werden mit 4 Mbit (Flash size) auf das Board geladen.
• Die schwarzen ESP-01-Boards (mit der Aufschrift "Cloud Inside") besitzen dagegen 1 MByte Flashspeicher und müssen mit 8 Mbit (Flash size) geladen werden.

Zusammenfassung

In dieser Folge haben wir uns näher mit dem Baustein ESP8266 beschäftigt, der sich sowohl mit dem Arduino koppeln als auch alleine betreiben lässt, sogar unter Nutzung der Arduino IDE. Für die in vielen Varianten und Leistungsstufen verfügbaren ESP8266-Boards gibt es unterschiedlichste Firmwarevarianten, was zu vielfältigen Einsatzmöglichkeiten führt. Aktuell hat espressif gerade den Nachfolger des ESP8266 namens ESP32 vorgestellt, der zusätzlich Bluetooth integriert. Eine zukünftige Folge adressiert den ESP32, sobald er auch wirklich verfügbar ist.

In der nächsten Folge geht es wieder hauptsächlich um den Arduino. Und zwar um die Frage: Wie lässt sich der ESP8266 für WLAN-Konnektivität des Arduino einsetzen?

Mehr Infos

Was bisher geschah:

• Bright Side of Arduino
• Genuino bzw. Arduino unplugged
• Arduino-/IoT-Extra – Bibliotheken selbst implementieren
• Kleiner, tiefer, kürzer ... Entwicklung einer Wetterstation
• RESTful mit CoAP
  
• Kommunikation über MQTT
• Schritt für Schritt
• Anwendungen mit Servo-Motoren
• Gut motorisiert mit Gleichstrommotoren
  
• Arduino für Fledermäuse
• Bewegungserkennung durch Infrarot-Strahlung
  
• Anschluss von LCD-Displays über den IIC-Bus
  
• Lauschen mit Sensoren
  
• JavaScript an Arduino: Es werde Licht
  
• Anschluss vieler LEDs an wenige Ausgänge
  
• Do-it-Yourself-Projekt: iXduino – Arduino on a Breadboard
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 3 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 2 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 1 von 3)

()