ESP-01 (ESP8266)

Das ESP8266 ESP-01 Modul -oder kurz ESP-01- ist ein kleines und kostengünstiges Modul mit einem Mikrocontroller und einer WLAN-Schnittstelle.
Der ESP-01 läuft nur mit 3,3V Betriebsspannung (max. 3,6V) und auch dessen GPIOs sind nicht 5V-tolerant. Wird das Modul mit einer höheren Spannung betrieben, kann es zerstört werden. Man kann also eine 3,3V-Spannungsquelle oder bei höheren Voltzahlen einen Spannungsregulator, z.B. den LM317 oder AMS1117, verwenden. Wichtig ist, das die Stromquelle oder der Spanungswandler mindestens 500mA Strom, besser mindestens 800mA bei 3,3V zur Verfügung stellen kann, sonst kann es zu unverhersagbarem Verhalten des ESPs in Form von Reboots o.ä. kommen.

Technische Daten laut Hersteller

• Betriebsspannung: 3,0V bis 3,6V
• Stromaufnahme: 80mA bis 170mA; Spitzenstrom bis 320mA; 0,1mA (DeepSleep laut Hersteller)
• Max. Stromaufnahme pro Pin: 12 mA
• Schnittstellen: Serial/UART, SDIO, SPI
• Netzwerk: WiFi 802.11 b/g/n 2,4 GHz mit WPA/WPA2 PSK
• Betriebstemperatur: -40°C bis +125°C
• Taktfrequenzen: 80MHz, 160MHz
• SRAM: < 36kB
• Flash-Speicher: 512kB bis 1MB (je nach Modell)
• Digitale I/O pins: 2× (GPIO0 + GPIO2)
• Analoge Pins: -keine-
• On-board LED-Pin: GPIO1 (= TX-Pin)

Verwendete Bauteile

• Grundlegende Werkzeuge und Hilfsmittel
• ESP-01 Modul (ESP8266)
• Arduino UNO (oder kompatibles Board)
• USB-Adapter/Programmer für ESP-01
• ESP-01 Breadboard-Adapter
• USB-Kabel (Typ A zu Typ A) (optional)
• LED (hier: 5mm, blau)
• 220Ω Widerstand
• 10kΩ Widerstand
• Fotowiderstand der GL55xx-Serie
• Bidirektionaler Pegelwandler (5V ↔ 3,3V)
• 18650 Li-Ionen-Akku
• 18650 Batterie-Board
• Steckkabel ("Jumperkabel")
• Steckbrett ("Breadboard")

Anschlüsse

Der ESP-01 hat 8 Pins, die allerdings so angeordnet sind, dass man das Board nicht direkt mit einem Breadboard verwenden kann. Auch wegen der (meist) fehlenden Beschriftung der Pins sind diese leicht zu verwechseln, daher empfiehlt sich die Anschaffung eines entsprechenden Breadboard-Adapters:

ESP-01 vs. ESP-01S

Programmierung

Es gibt mehrere Möglichkeiten, den ESP-01 zu programmieren, aber ich habe mich für die Verwendung eines Programmers mit USB-Anschluss entschieden. Den Code werde ich über die Arduino-IDE kompilieren und hochladen.

Programmer

Es gibt spezielle Programmer mit USB-Schnittstelle, die das hochladen von Sketches auf den ESP-01 sehr einfach machen. In meinem Fall besitzt der Programmer einen kleinen Schiebeschalter, der zwischen PROG und UART wählen lässt. Zur Programmierung, sollte der Schalter deshalb immer auf PROG stehen.

Arduino-IDE vorbereiten

Um Sketches mit der Arduino-IDE für den ESP-01 kompilieren und hochladen zu können müssen zunächst einige Vorbereitungen getroffen werden. Man fügt unter "Voreinstellungen → Zusätzliche Boardverwalter-URLs" folgende URL hinzu: http://arduino.esp8266.com/stable/package_esp8266com_index.json.
Falls schon eine andere URL in diesem Feld steht, kann diese mit einem Komma separiert werden.
Dann muss das ESP-01 Board hinzugefügt werden. Dazu geht man unter "Werkzeuge → Boards → Boardverwalter": Hier sucht man nach "esp8266" und installiert dann "esp8266 by ESP8266 Commnunity".
(siehe auch: Arduino core for ESP8266 WiFi chip)

Im Menu "Werkzeuge → Board:" sollte nun das Board "Generic ESP8266 Board" ausgewählt werden. Es gibt hier eine Menge Optionen, jedoch habe ich die voreingestellten Werte beibehalten und die Programmierung funktionierte ohne Probleme:

Nun kann der ESP-01 mit dem Programmer an den USB-Port des PC angesteckt werden und man wählt nun den Port aus im Menu "Werkzeuge → Port:".
Falls unter Windows der COM Port nicht wählbar ist, muss noch zusätzlich die USB to UART Bridge installiert werden.

Für die ersten drei Experimente wird nur der ESP-01 mit Programmer benötigt. Nur im vierten Versuch ist ein spezieller Aufbau nötig.

Experiment I.: Interne LED des ESP-01 blinkt

Die interne (blaue) LED liegt bei den meisten ESP-01-Modulen an GPIO1, bei meinem allerdings auf GPIO2 (dies kann in der Arduino-IDE im Werkzeuge-Menu eingestellt werden). Diese eingebaute LED hat zwei Besonderheiten: Sie ist active LOW, so dass sich das Verhalten von digitalWrite() umkehrt. Außerdem teil sie sich den Pin mit TX, so dass man die interne LED nicht gleichzeitig mit Serial.***-Befehlen verwenden kann.

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  digitalWrite(LED_BUILTIN, LOW); // LED wird hier eingeschaltet (active LOW)
  delay(500);
  digitalWrite(LED_BUILTIN, HIGH); // LED wird hier ausgeschaltet (active LOW)
  delay(1500);
}

Nach dem erfolgreichen Hochladen des Sketches über den Programmer wird der ESP-01 über den kleinen Adapter auf ein Breadboard angeschlossen (Richtung beachten!). Mit einem 18650-Batterie-Board wird eine 3V-Stromversorgung angeschlossen und die interne LED beginnt zu blinken.

Experiment II.: ESP-01 verbindet sich mit WLAN

Im zweiten Sketch soll der ESP-01 sich zum lokalen WLAN-Netzwerk verbinden. Dies geschieht mit Hilfe der Library ESP8266WiFi.h, die schon beim Board-Manager-Paket mitgeliefert wird. (Mein Fehler war zunächst, eine separate Library desselben Namens zusätzlich zu installieren, worauf die Arduino-IDE beim Kompilieren des Sketches etliche Fehlermeldungen warf. Nach manuellem Entfernen letzter Library lief wieder alles ohne Probleme)

#include <ESP8266WiFi.h>

const char* WIFI_SSID     = "xxxxxxxxxx";
const char* WIFI_PASSWORD = "xxxxxxxxxx";

void setup()
{
  Serial.begin(9600);

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }

  Serial.println("WiFi connected.");
  for (byte i = 0; i < 10; i++) {
    Serial.println(WiFi.localIP());
    delay(2000);
  }

  WiFi.disconnect();
  Serial.println("WiFi disconnected.");
}

void loop() {}

Resultat

Wenn sich das ESP-01-Modul mit dem lokalen WLAN verbinden kann, dann wird folgende Ausgabe auf der seriellen Konsole angezeigt:

Experiment III.: ESP-01 sendet Http-Request an Webserver

Nach dem erfolgreichen Verbinden mit dem WLAN werden wir nun einen Webserver per GET-Request anfragen und die Antwort auf der seriellen Konsole anzeigen lassen:

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

const char* WIFI_SSID     = "xxxxxxxxxx";
const char* WIFI_PASSWORD = "xxxxxxxxxx";

const char* HOST_URL = "http://example.com/";

HTTPClient http;
WiFiClient client;

void setup()
{
  Serial.begin(9600);

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }

  http.begin(client, HOST_URL);
  Serial.println(http.GET());
  Serial.println(http.getString());
  http.end();

  WiFi.disconnect();
}

void loop() {}

Resultat

Wenn sich das ESP-01-Modul mit dem lokalen WLAN verbinden kann und die Anfrage an den Webserver durchgeführt hat, dann wird folgende Ausgabe auf der seriellen Konsole angezeigt:

Experiment IV.: Arduino sendet Daten mit dem ESP-01 in IoT

Im letzten Versuch werden Sensordaten vom Arduino gesammelt und über die serielle Schnittstelle (UART) an den ESP-01 weitergegeben, der wiederum diese Daten ins IoT (hier: ThingSpeak) sendet.

Aufbau der Schaltung

Der Schaltplan zeigt, dass als Sensor hier exemplarisch ein LDR verwendet wird, der die aktuelle Helligkeit messen soll. Zum Überprüfen der Helligkeit wird eine blaue LED direkt an den gemessenen Helligkeitswert umgekehrt gekoppelt. Da der Arduino UNO mit 5V arbeitet und der ESP-01 mit 3,3V und NICHT 5V-tolerant ist, muss ein Pegelwandler dazwischen geschaltet werden. Als Spannungsquelle dient ein 18650-Batterie-Board, welches sowohl 5V- als auch 3V-Spannung liefern kann.

Sketch für den Arduino Uno

#define PIN_LDR A0
#define PIN_LED 10

void setup()
{
  pinMode(PIN_LED, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  static int brightness = 0, ldr = 0;
  ldr = analogRead(PIN_LDR);
  brightness = min(254, max(0, map(ldr, 150, 800, 254, 0)));
  analogWrite(PIN_LED, brightness);
  Serial.write(ldr);
  delay(500);
}

Sketch für den ESP-01

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

#define REPORT_DELAY 15 // in seconds

const char* WIFI_SSID     = "xxxxxxxxxx";
const char* WIFI_PASSWORD = "xxxxxxxxxx";

// ThingSpeak settings
const char* THINGSPEAK_URL = "http://api.thingspeak.com/update";
const char* WRITE_API_KEY  = "xxxxxxxxxx";

#define lmillis() ((long)millis())

HTTPClient http;
WiFiClient client;
long nextReport = 0;
int ldrValue = 0;

void setup()
{
  Serial.begin(9600);
  nextReport = lmillis() + REPORT_DELAY * 1000;
}

void loop()
{
  if (Serial.available() > 0) {
    ldrValue = (int)Serial.read();
  }

  if (lmillis() - nextReport >= 0) {
    nextReport = lmillis() + REPORT_DELAY * 1000;
    requestIot();
  }
}

void connectWiFi()
{
  if (WiFi.status() == WL_CONNECTED) {
    return;
  }
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
}

void requestIot()
{
  connectWiFi();
  String request = String(THINGSPEAK_URL) + "?api_key=" + String(WRITE_API_KEY) + "&field1=" + String(ldrValue);
  http.begin(client, request.c_str());
  http.GET();
  http.end();
}

Resultat

Die gemessenen Werte werden zu ThingSpeak übertragen und dann in einem Diagram angezeigt:

Weiterführende Links

• Was ist ESP8266?
• Getting Started with the ESP8266
• Breadboard and Program an ESP-01 Circuit with the Arduino IDE
• ESP8266 Programming Using FTDI and Arduino IDE
• ESP8266 ESP-01 Modul
• Update Flash ESP8266 Firmware – Flashing Official AT Firmware
• Arduino goes ESP8266