ESP-01 (ESP8266)

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

Verwendete Bauteile

Anschlüsse

Anschlüsse des ESP-01
Nr. Pin Funktion
1 GND Masse/Ground
2 GPIO2 GPIO (mit internem Pullup-Widerstand)
3 GPIO0 GPIO (mit internem Pullup-Widerstand)
4 RXD UART0 (Dateneingang)
5 VCC Spannungsversorgung mit 3,3V (VDD)
6 RST Reset-Pin (active LOW)
7 CH_PD CHIP ENABLE (active HIGH)
8 TXD UART0 (Datenausgang)

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:

Breadboard-Adapter für den ESP-01
Abb.: Breadboard-Adapter für den ESP-01

ESP-01 vs. ESP-01S

ESP-01 ESP-01S
512 kB Flash-Speicher 1 MB Flash-Speicher
Rote Betriebs-LED Keine Betriebs-LED
Interne, blaue LED auf TX Interne, blaue LED auf GPIO2 (active LOW)
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.

Programmer für den ESP-01
Abb.: Programmer für den ESP-01 mit bereits aufgestecktem ESP-01-Board

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)

ESP8266 in der Arduino-IDE installieren
Abb.: ESP8266 in der Arduino-IDE installieren

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:

Board-Menu in der Arduino-IDE
Abb.: Board-Menu in der Arduino-IDE mit Standard-Einstellungen

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.

Interne LED des ESP-01 blinkt
Abb.: Interne LED des ESP-01 blinkt

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:

Ausgabe auf der seriellen Konsole
Abb.: Ausgabe auf der seriellen Konsole der Arduino-IDE

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:

Ausgabe auf der seriellen Konsole
Abb.: Ausgabe auf der seriellen Konsole der Arduino-IDE

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.

Schaltplan mit Arduino Uno und ESP-01

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:

Ausgabe der übertragenen Werte in ThingSpeak
Abb.: Ausgabe der übertragenen Werte in ThingSpeak

Weiterführende Links

zurück