ESP-01 mit Arduino: AT-Befehle, Programmieren und Relais

Der ESP-01 ist ein winziges (24,8 × 14,3 mm) und sehr günstiges Modul mit dem WLAN-Chip ESP8266. Wenn du den ESP-01 an einen Arduino anschließt, bekommt ein Board ohne Funk wie der Uno oder Nano mit wenigen Kabeln WLAN. Das Modul kommt ab Werk mit einer AT-Befehls-Firmware: Der Arduino schickt über die serielle Schnittstelle kurze Textbefehle wie "AT+CWJAP", und der ESP-01 verbindet sich mit dem Netzwerk, sendet und empfängt Daten. Du kannst den ESP-01 aber auch ganz ohne Arduino als eigenständigen Mikrocontroller programmieren; sein Prozessor ist deutlich schneller als der des Uno.

In dieser Anleitung lernst du die 8 Pins des ESP-01 kennen und erfährst, warum er unbedingt eine kräftige 3,3-V-Versorgung braucht. Danach geht es Schritt für Schritt um AT-Befehle mit dem Arduino Uno, eine Webseite, die per Handy eine LED schaltet, das direkte Programmieren mit einem USB-TTL-Adapter (GPIO0 an GND), die Lampensteuerung mit dem ESP-01S-Relaismodul und den Einsatz am Raspberry Pi Pico. Am Ende findest du Lösungen für die häufigsten Fehler und erfährst, wann ein NodeMCU oder ESP32 die bessere Wahl ist.

Was ist der ESP-01 und wie funktioniert er?

Der ESP-01 ist das erste und kleinste Modul, das Ai-Thinker rund um den ESP8266EX-Chip entwickelt hat. Auf der Platine sitzen der Chip, ein 26-MHz-Quarz, der Flash-Speicher für Programm und Einstellungen und eine mäanderförmige PCB-Antenne; einen USB-Anschluss, Spannungsregler oder Taster gibt es nicht. Deshalb kannst du den ESP-01 nicht direkt an den Computer stecken: Versorgung und serielle Verbindung musst du selbst herstellen. Du kannst das Modul auf zwei Arten nutzen: als WLAN-Modem (die AT-Firmware ist aufgespielt, der Arduino schickt Befehle) oder als eigenständigen Mikrocontroller (du lädst dein eigenes Programm aus der Arduino IDE hoch, die AT-Firmware wird dabei gelöscht). Die meisten heute verkauften Module sind die schwarze Version ESP-01S.

Unterschied zwischen ESP-01 und ESP-01S

ESP-01 Pinbelegung: die 8 Pins im Überblick

Der ESP-01 hat 8 Pins in einer 2×4-Stiftleiste, und nur vier davon lassen sich als Ein- und Ausgänge nutzen. Nicht auf jeder Platine stehen die Pinnamen; vergleiche dein Modul vor dem Verdrahten mit dem Pinout des Händlers, denn vertauschte VCC- und GND-Anschlüsse zerstören das Modul in Sekunden. So sind die Pins belegt und im Normalbetrieb angeschlossen:

Strombedarf: Warum der 3,3-V-Pin des Arduino nicht reicht

Die meisten Probleme, bei denen der ESP-01 kaputtgeht oder ständig neu startet, kommen von der Stromversorgung. Mit WLAN-Verbindung zieht das Modul im Mittel 70–80 mA, beim Senden um die 170 mA; beim Booten und beim Verbinden mit dem Netzwerk können kurze Spitzen über 300 mA liegen. Der 3,3-V-Pin des Arduino Uno ist dagegen offiziell nur für 50 mA ausgelegt. Ein ESP-01 an diesem Pin antwortet oft noch auf den Befehl "AT", aber sobald er sich mit dem Netzwerk verbinden will, bricht die Spannung ein und das Modul startet neu, was wie ein Softwarefehler aussieht. Die Lösung ist ein AMS1117-3.3-Spannungsregler (1 A), der aus 5 V gespeist wird, plus ein Elko mit 100–470 µF zwischen VCC und GND des Moduls. Wie Spannungsregler funktionieren, erfährst du im Artikel zum Spannungsregler 7805.

ESP-01 an den Arduino Uno anschließen (für AT-Befehle)

Die einzige Hardware-Schnittstelle des Arduino Uno (D0 und D1) teilt er sich mit der USB-Verbindung. Am praktischsten ist es deshalb, den ESP-01 mit der Bibliothek SoftwareSerial an D2 und D3 anzuschließen: Beim Hochladen auf den Uno musst du den ESP-01 nicht abziehen, und der serielle Monitor bleibt fürs Debuggen frei. Der Raspberry Pi Pico arbeitet ohnehin mit 3,3 V und braucht keinen Spannungsteiler:

Um das 5-V-Signal vom D3-Pin des Uno abzusenken, schaltest du 1 kΩ von D3 zum RX des ESP-01 und 2 kΩ vom RX des ESP-01 nach GND. Die Ausgangsspannung beträgt 5 × 2 / (1 + 2) = 3,33 V; mit 2,2 kΩ statt 2 kΩ erhältst du 3,44 V, beides ist sicher. Andere Widerstandswerte kannst du mit dem Spannungsteiler-Rechner berechnen. In die andere Richtung brauchst du keinen Teiler: Die 3,3 V vom TX-Pin des ESP-01 liegen über der 3-V-Schwelle, ab der der Uno HIGH erkennt. Die Grundlagen der seriellen Kommunikation erklären wir ausführlich im Artikel UART serielle Kommunikation.

Erster Test: AT-Befehle über den seriellen Monitor senden

1. Lade den Brücken-Sketch unten auf den Uno; setze ESP_BAUD beim ersten Versuch auf 115200, denn die meisten Module kommen mit dieser Geschwindigkeit (ältere eventuell mit 9600).
2. Öffne den seriellen Monitor mit 115200 Baud und stelle das Zeilenende auf Both NL & CR; ohne diese Einstellung erkennt das Modul das Befehlsende nicht.
3. Tippe AT und sende es; du solltest OK sehen. Kommen nur wirre Zeichen, stimmt die Baudrate nicht.
4. SoftwareSerial liest bei 115200 Baud nicht zuverlässig, also senke die Geschwindigkeit des Moduls mit AT+UART_DEF=9600,8,1,0,0 dauerhaft auf 9600. Auch wenn die Antwort verstümmelt aussieht, kommt der Befehl meist an.
5. Ändere ESP_BAUD im Sketch auf 9600, lade ihn erneut hoch und wiederhole den AT-Befehl; die OK-Antwort sollte jetzt sauber sein.
6. Prüfe mit AT+GMR die Firmware-Version und mit AT+CWLAP die WLAN-Netze in der Nähe, um sicherzugehen, dass das Modul richtig funktioniert.

1#include <SoftwareSerial.h>
2
3SoftwareSerial esp(2, 3);          // D2 = RX, D3 = TX (bölücüyle ESP RX'e) / D3 to ESP RX via divider
4
5const long ESP_BAUD = 9600;        // ilk denemede 115200 yap / use 115200 on the first try
6
7void setup() {
8  Serial.begin(115200);            // Seri Monitör hızı / Serial Monitor speed
9  esp.begin(ESP_BAUD);
10  Serial.println("AT komutu yaz / type an AT command");
11}
12
13void loop() {
14  if (esp.available()) {           // ESP-01'den geleni ekrana yaz / ESP-01 -> screen
15    Serial.write(esp.read());
16  }
17  if (Serial.available()) {        // klavyeden yazılanı ESP-01'e gönder / keyboard -> ESP-01
18    esp.write(Serial.read());
19  }
20}

Die wichtigsten AT-Befehle für den ESP-01

LED per Handy schalten mit Arduino Uno und ESP-01

Jetzt machen wir aus den AT-Befehlen ein Programm. Der folgende Sketch verbindet den ESP-01 mit deinem Netzwerk, startet auf Port 80 einen kleinen Webserver und gibt die IP-Adresse im seriellen Monitor aus. Gibst du diese Adresse im Browser eines Handys im selben WLAN ein, öffnet sich eine Seite mit zwei Knöpfen, die die eingebaute LED an Pin 13 des Uno ein- und ausschalten. Schließt du statt der LED ein Relaismodul an, steuerst du auf die gleiche Weise eine Lampe. Vor dem Hochladen solltest du die Geschwindigkeit des Moduls im vorigen Schritt auf 9600 gestellt haben.

1#include <SoftwareSerial.h>
2
3SoftwareSerial esp(2, 3);              // D2 = RX, D3 = TX (bölücüyle) / D3 via divider
4const int LED_PIN = 13;                // Uno'nun dahili LED'i / Uno onboard LED
5
6const char* WIFI_SSID = "AgAdi";       // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123";    // Wi-Fi şifren / your Wi-Fi password
8
9bool ledOn = false;
10bool pending = false;                  // cevap bekleyen istek var mı / request waiting for a reply
11int linkId = 0;                        // ESP-01'in bağlantı numarası (0-4) / connection id (0-4)
12char line[64];
13byte lineLen = 0;
14
15// Beklenen yazıyı süre dolana kadar ara / wait until the expected text arrives or time runs out
16bool waitFor(const char* expect, unsigned long timeout) {
17  unsigned long start = millis();
18  size_t idx = 0;
19  size_t len = strlen(expect);
20  while (millis() - start < timeout) {
21    if (esp.available()) {
22      char c = esp.read();
23      Serial.write(c);                 // gelen her şeyi göster / echo everything
24      if (c == expect[idx]) {
25        idx++;
26        if (idx == len) return true;
27      } else {
28        idx = (c == expect[0]) ? 1 : 0;
29      }
30    }
31  }
32  return false;
33}
34
35bool sendAT(const char* cmd, const char* expect, unsigned long timeout) {
36  esp.println(cmd);                    // println sonuna \r\n ekler / println adds \r\n
37  return waitFor(expect, timeout);
38}
39
40void sendPage(int id) {
41  char body[220];
42  snprintf(body, sizeof(body),
43           "<meta name='viewport' content='width=device-width'>"
44           "<h2>LED: %s</h2>"
45           "<a href='/on'><button>AC / ON</button></a> "
46           "<a href='/off'><button>KAPAT / OFF</button></a>",
47           ledOn ? "ACIK / ON" : "KAPALI / OFF");
48  char head[110];
49  snprintf(head, sizeof(head),
50           "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n"
51           "Content-Length: %d\r\nConnection: close\r\n\r\n",
52           (int)strlen(body));
53
54  esp.print("AT+CIPSEND=");            // önce kaç bayt gideceğini söyle / announce the length first
55  esp.print(id);
56  esp.print(',');
57  esp.println(strlen(head) + strlen(body));
58  if (waitFor(">", 2000)) {            // ">" gelince veriyi yolla / send data after ">"
59    esp.print(head);
60    esp.print(body);
61    waitFor("SEND OK", 5000);
62  }
63  esp.print("AT+CIPCLOSE=");           // bağlantıyı kapat / close the connection
64  esp.println(id);
65  waitFor("OK", 2000);
66}
67
68void handleLine() {
69  if (strncmp(line, "+IPD,", 5) == 0) {          // yeni istek / new request: +IPD,0,384:GET /on ...
70    linkId = line[5] - '0';
71    if (strstr(line, "GET /on ")) ledOn = true;
72    else if (strstr(line, "GET /off ")) ledOn = false;
73    digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
74    pending = true;
75  } else if (pending && lineLen == 0) {           // boş satır = isteğin sonu / empty line = end of request
76    pending = false;
77    sendPage(linkId);
78  }
79}
80
81void setup() {
82  pinMode(LED_PIN, OUTPUT);
83  Serial.begin(115200);
84  esp.begin(9600);                     // AT+UART_DEF=9600,8,1,0,0 ile ayarlanmış olmalı / set with AT+UART_DEF
85
86  sendAT("AT+RST", "ready", 5000);     // temiz başlangıç / clean restart
87  sendAT("AT+CWMODE=1", "OK", 2000);   // istemci modu / station mode
88
89  esp.print("AT+CWJAP=\"");            // AT+CWJAP="ad","şifre" / AT+CWJAP="ssid","password"
90  esp.print(WIFI_SSID);
91  esp.print("\",\"");
92  esp.print(WIFI_PASS);
93  esp.println("\"");
94  if (!waitFor("OK", 20000)) {
95    Serial.println(F("\nWi-Fi baglanamadi / Wi-Fi failed"));
96  }
97
98  sendAT("AT+CIPMUX=1", "OK", 2000);         // sunucu için çoklu bağlantı / multiple connections
99  sendAT("AT+CIPSERVER=1,80", "OK", 2000);   // 80 portunda sunucu / server on port 80
100  sendAT("AT+CIFSR", "OK", 2000);            // IP adresini yaz / print the IP address
101}
102
103void loop() {
104  while (esp.available()) {            // ESP-01'den gelenleri satır satır oku / read line by line
105    char c = esp.read();
106    if (c == '\n') {
107      line[lineLen] = '\0';
108      handleLine();
109      lineLen = 0;
110    } else if (c != '\r' && lineLen < sizeof(line) - 1) {
111      line[lineLen++] = c;
112    }
113  }
114}

So funktioniert der Code: Verbindet sich ein Browser, leitet der ESP-01 die Anfrage als +IPD,0,384:GET /on HTTP/1.1 an den Arduino weiter; 0 ist die Verbindungsnummer, 384 die Anzahl empfangener Bytes. Der Arduino sucht in dieser Zeile nach "GET /on" oder "GET /off" und setzt die LED. Kommt die Leerzeile, die das Ende der Anfrage markiert, kündigt er mit AT+CIPSEND=0,Länge an, wie viele Bytes er senden will, schickt die Seite, sobald das Modul das Zeichen ">" zeigt, und schließt die Verbindung nach der Antwort "SEND OK" mit AT+CIPCLOSE. Die Seite ist absichtlich kurz: Die 2 KB RAM des Uno reichen nicht für lange HTML-Texte, und ein einzelnes CIPSEND kann höchstens 2048 Byte senden. Bei komplexeren Projekten nimmt dir eine Bibliothek wie WiFiEspAT die Verwaltung der AT-Befehle ab.

ESP-01 direkt programmieren: GPIO0 an GND legen

Der ESP8266 im ESP-01 ist mit seinem 32-Bit-Prozessor und 80 MHz deutlich leistungsfähiger als ein Arduino Uno. Besteht dein Projekt nur aus einem Relais, einem Sensor oder einer LED, brauchst du gar keinen Arduino: Du lädst das Programm direkt auf den ESP-01. Beim Start prüft der ESP8266 die Pegel an GPIO0, GPIO2 und GPIO15 und entscheidet danach, was er tut. Auf der ESP-01-Platine liegt GPIO15 bereits an GND und GPIO2 muss HIGH bleiben; damit bestimmt allein GPIO0 den Bootmodus:

1. Öffne in der Arduino IDE Datei > Einstellungen und trage https://arduino.esp8266.com/stable/package_esp8266com_index.json im Feld "Zusätzliche Boardverwalter-URLs" ein.
2. Suche im Boardverwalter nach esp8266 und installiere das Paket der ESP8266 Community.
3. Wähle unter Werkzeuge > Board das Generic ESP8266 Module. Stelle Flash Size beim ESP-01S auf 1MB (FS:64KB OTA:~470KB), beim alten blauen ESP-01 auf eine der 512KB-Optionen.
4. Stelle den Jumper des USB-TTL-Adapters auf 3,3 V, verdrahte das Modul nach der Tabelle oben und lass GPIO0 an GND.
5. Trenne die Versorgung des Moduls kurz oder tippe RST kurz an GND; das Modul startet jetzt im Programmiermodus.
6. Wähle unter Werkzeuge > Port den Port des USB-TTL-Adapters und lade den Sketch hoch. Als erster Test eignet sich Datei > Beispiele > ESP8266 > Blink; beim ESP-01S hängt die blaue LED an GPIO2.
7. Sobald "Hard resetting via RTS pin..." erscheint, trennst du GPIO0 von GND und startest das Modul neu. Bleibt GPIO0 an GND, läuft dein Programm nicht und das Modul startet wieder im Programmiermodus.

Relais schalten mit GPIO0 und GPIO2: das ESP-01S-Relaismodul

Die frei nutzbaren Pins des ESP-01 sind GPIO0 und GPIO2, doch beide müssen beim Booten HIGH sein. Was du daran anschließt, darf den Pin beim Start also nicht auf LOW ziehen. Am sichersten ist eine LOW-aktive Ansteuerung: Beim Booten ist der Pin HIGH und das Relais bleibt aus; setzt dein Programm den Pin auf LOW, zieht das Relais an. Das fertige ESP-01S-Relaismodul ist genau so aufgebaut: Es wird mit 5 V versorgt, ein Regler auf der Platine erzeugt 3,3 V für den ESP-01S, und GPIO0 steuert über einen Transistor ein Relais mit 10-A-250-V-AC-Kontakten. Bei Platinen ab v4.0 zieht das Relais an, wenn GPIO0 LOW ist; ältere v1.0-Platinen brauchen für den ESP-01S eventuell eine kleine Änderung, prüfe also die Version deiner Platine.

1#include <ESP8266WiFi.h>
2#include <ESP8266WebServer.h>
3#include <ESP8266mDNS.h>
4
5const char* ssid = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
7
8const int RELAY_PIN = 0;               // ESP-01S röle kartında GPIO0 / GPIO0 on the ESP-01S relay board
9const int RELAY_ON = LOW;              // çoğu kartta LOW = çeker; tersse değiştir / LOW = on, swap if yours is inverted
10const int RELAY_OFF = HIGH;
11
12ESP8266WebServer server(80);
13bool relayOn = false;
14
15void sendPage() {
16  String html = F("<!DOCTYPE html><html><head><meta charset='utf-8'>"
17                  "<meta name='viewport' content='width=device-width,initial-scale=1'>"
18                  "<title>ESP-01</title></head>"
19                  "<body style='font-family:sans-serif;text-align:center'>"
20                  "<h1>ESP-01 Röle / Relay</h1><p><b>");
21  html += relayOn ? "AÇIK / ON" : "KAPALI / OFF";
22  html += F("</b></p><p><a href='/on'><button>AÇ / ON</button></a> "
23            "<a href='/off'><button>KAPAT / OFF</button></a></p></body></html>");
24  server.send(200, "text/html", html);
25}
26
27void setRelay(bool on) {
28  relayOn = on;
29  digitalWrite(RELAY_PIN, on ? RELAY_ON : RELAY_OFF);
30  server.sendHeader("Location", "/");  // ana sayfaya dön / back to the main page
31  server.send(303, "text/plain", "");
32}
33
34void setup() {
35  digitalWrite(RELAY_PIN, RELAY_OFF);  // önce kapalı seviye / off level first
36  pinMode(RELAY_PIN, OUTPUT);
37  Serial.begin(115200);
38
39  WiFi.mode(WIFI_STA);
40  WiFi.begin(ssid, password);
41  while (WiFi.status() != WL_CONNECTED) {
42    delay(500);
43    Serial.print('.');
44  }
45  Serial.println();
46  Serial.println(WiFi.localIP());      // bu adresi tarayıcıda aç / open this address in a browser
47  MDNS.begin("esp01");                 // ya da http://esp01.local / or http://esp01.local
48
49  server.on("/", sendPage);
50  server.on("/on", []() { setRelay(true); });
51  server.on("/off", []() { setRelay(false); });
52  server.begin();
53}
54
55void loop() {
56  server.handleClient();
57  MDNS.update();
58}

Nachdem du den Sketch wie oben beschrieben auf den ESP-01S geladen hast, steckst du das Modul auf die Relaisplatine und versorgst sie mit 5 V. Die IP-Adresse liest du bei angeschlossenem USB-TTL-Adapter im seriellen Monitor ab oder findest sie in der Geräteliste deines Routers; von einem Computer mit mDNS-Unterstützung funktioniert auch http://esp01.local. Willst du einen Eingang wie einen Taster ergänzen, ist GPIO3 (RX) der beste Pin, denn sein Pegel spielt beim Booten keine Rolle. Öffne die serielle Schnittstelle dann mit Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY) nur in Senderichtung.

ESP-01 am Raspberry Pi Pico (MicroPython)

Auch einem Raspberry Pi Pico ohne WLAN kannst du mit dem ESP-01 Funk verschaffen. Da der Pico mit 3,3 V arbeitet, brauchst du keinen Spannungsteiler: RX des ESP-01 kommt an GP0 (UART0 TX), TX an GP1 (UART0 RX). Der Hardware-UART des Pico liest 115200 Baud problemlos, du musst die Geschwindigkeit des Moduls also nicht ändern; hast du sie im Uno-Abschnitt schon auf 9600 gesenkt, setz auch baudrate im Code auf 9600. Führe den MicroPython-Code unten in Thonny aus; das Modul verbindet sich mit dem Netzwerk, gibt seine IP-Adresse aus und listet alle 30 Sekunden die WLAN-Netze in der Nähe. Hast du einen Pico W, ist das eingebaute WLAN einfacher; schau dir dazu den Artikel Pico W WLAN-Webserver an.

1from machine import UART, Pin
2import time
3
4# GP0 (TX) -> ESP-01 RX, GP1 (RX) <- ESP-01 TX
5uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))
6
7def at(cmd, timeout=2000):
8    uart.write(cmd + "\r\n")                   # her komut \r\n ile biter / every command ends with \r\n
9    start = time.ticks_ms()
10    resp = b""
11    while time.ticks_diff(time.ticks_ms(), start) < timeout:
12        if uart.any():
13            resp += uart.read()
14            if b"OK" in resp or b"ERROR" in resp or b"FAIL" in resp:
15                break
16    print(cmd, "->", resp)                     # cevabı göster / show the reply
17    return resp
18
19at("ATE0")                                     # komut yankısını kapat / turn off echo
20at("AT")                                       # OK gelmeli / should answer OK
21at("AT+CWMODE=1")                              # istemci modu / station mode
22at('AT+CWJAP="AgAdi","Sifre123"', 20000)       # Wi-Fi'ye bağlan / join Wi-Fi
23at("AT+CIFSR")                                 # IP adresini sor / ask for the IP
24
25while True:
26    at("AT+CWLAP", 10000)                      # çevredeki ağları tara / scan nearby networks
27    time.sleep(30)

ESP-01, NodeMCU oder ESP32?

Die größten Vorteile des ESP-01 sind Größe und Preis; er ist ideal, um ein bestehendes Arduino-Projekt um WLAN zu erweitern oder ein einzelnes Relais oder einen Sensor funkfähig zu machen. Weil er aber kein USB hat, sind Umstecken, Regler und GPIO0 an GND bei jedem Hochladen mühsam. Er hat keinen Analogeingang, und da GPIO16 nicht herausgeführt ist, funktioniert das zeitgesteuerte Aufwachen aus dem Deep Sleep nur, wenn du einen dünnen Draht an einen Pin des Chips lötest. Planst du ein Akkuprojekt, gib den mittleren Verbrauch in den Akkulaufzeit-Rechner ein und sieh nach, wie viele Tage es durchhält. Lernst du noch oder brauchst du mehr als drei Pins, bietet dir der NodeMCU ESP8266 denselben Chip mit USB und Regler. Brauchst du Bluetooth, mehr Pins und mehr Rechenleistung, ist der ESP32 die richtige Wahl; die Boards vergleichen wir im Artikel Arduino oder ESP32?

Projektideen mit dem ESP-01

• WLAN-Steckdose: Schalte mit dem ESP-01S-Relaismodul und dem Sketch oben eine Lampe per Handy; mit einem Timer geht sie abends automatisch an.
• Funk-Temperatursensor: Schließe einen DS18B20 an GPIO2 an; der 4,7-kΩ-Pull-up an der Datenleitung sorgt zugleich für den HIGH-Pegel, den der Bootvorgang braucht.
• Feuchte- und Temperaturanzeige: Zeige die Messwerte eines DHT11 auf einer Webseite an, die du am Handy öffnest.
• Bewegungsmelder mit Nachricht: Schließe einen PIR-Sensor an GPIO3 an und schicke bei Bewegung eine Telegram-Nachricht; das Vorgehen ähnelt stark dem Artikel ESP32 Telegram-Bot.
• WLAN für ein Arduino-Projekt: Schicke die Messwerte einer Wetterstation mit dem Uno per AT-Befehle an ein Programm auf deinem Computer oder an einen Server.
• Garagentor-Fernbedienung: Schalte die Relaiskontakte parallel zum Taster des Torantriebs und öffne das Tor per Handy.

Typische Fehler und ihre Lösungen

Trotz seiner geringen Größe ist der ESP-01 ein tolles Modul, um alle Grundbegriffe des WLAN zu lernen: IP-Adressen, TCP-Verbindungen, Webserver und serielle Kommunikation. Klappt etwas nicht, prüfe zuerst die Versorgung, dann die TX-RX-Leitungen und den Pegel an GPIO0; die allermeisten Probleme liegen an diesen drei Stellen. In der BlueGrays-App findest du Projekte wie WLAN-Verbindung, Webserver, mDNS, Updates per Funk (OTA) und intelligente Beleuchtung mit Relais, jeweils mit Schaltplan und Code Schritt für Schritt.