Wemos D1 mini Pinbelegung: D0–D8, GPIO, A0, Shields, Deep Sleep
Wemos D1 mini Pinbelegung erklärt: D0–D8 und ihre GPIOs, kritische Boot-Pins, die 3,2-V-Grenze an A0, Relais-, DHT- und OLED-Shield sowie Deep Sleep mit D0–RST.
Der Wemos D1 mini packt den WLAN-Chip ESP8266 auf eine Platine von 34 × 26 mm, wird direkt über USB programmiert und lässt sich mit aufsteckbaren Shields erweitern – damit gehört er zu den beliebtesten Mini-Entwicklungsboards überhaupt. Er ist klein, günstig und Arduino-IDE-kompatibel und deshalb erste Wahl für WLAN-Sensoren, smarte Steckdosen und LED-Streifen-Steuerungen. Der Haken: Die Beschriftungen D0–D8 auf dem Board sind keine GPIO-Nummern, und manche Pins verhindern bei falscher Beschaltung, dass das Board überhaupt startet – deshalb brauchst du zuerst eine klare Wemos D1 mini Pinbelegung.
In dieser Anleitung findest du die komplette Wemos D1 mini Pinbelegung in einer Tabelle mit der GPIO-Nummer jedes Pins. Mit Beispielcode zeigen wir, welche Pins beim Booten kritisch sind, warum der Analogeingang A0 bei 3,2 V endet, welche Pins Relais-, DHT- und OLED-Shield belegen und warum D0 für den Deep Sleep mit RST verbunden werden muss. Zum Schluss werfen wir einen kurzen Blick auf die Geschwister mit ESP32.

Was ist der Wemos D1 mini? Technische Daten
Der D1 mini stammt von Wemos (heute LOLIN) und wurde dank seines offenen Schaltplans von vielen Herstellern nachgebaut. Im ESP-12-Modul mit Metallabschirmung stecken der Prozessor ESP8266EX und 4 MB Flash; auf der Platine sitzen zusätzlich ein USB-Seriell-Wandler, ein Spannungsregler von 5 V auf 3,3 V und der RESET-Taster. Verbreitet sind die Version v3 mit Micro-USB und v4 mit USB-C; die Pinbelegung ist bei allen gleich.
| Eigenschaft | Wert |
|---|---|
| Chip | ESP8266EX, 32 Bit, 80/160 MHz |
| Flash | 4 MB (D1 mini Pro: 16 MB) |
| RAM | 80 KB Datenspeicher (mit WLAN etwa 40–50 KB frei) |
| WLAN | 802.11 b/g/n, nur 2,4 GHz |
| Digitale Pins | 11 (D0–D8, TX, RX) |
| Analogeingang | 1 (A0, 0–3,2 V, 10 Bit) |
| Logikpegel | 3,3 V (Versorgung über USB oder den 5V-Pin) |
| USB-Seriell-Chip | Meist CH340 |
| Größe | 34,2 × 25,6 mm |
Wemos D1 mini Pinbelegung: D0–D8 und die zugehörigen GPIOs
Der häufigste Fehler: Man schreibt die Beschriftung als Zahl in den Code. Mit pinMode(4, OUTPUT) nutzt das Board in der Arduino IDE nicht D4, sondern GPIO 4, also D2. Verwende im Code entweder die Konstanten wie D4 (sie sind definiert, wenn als Board der D1 mini gewählt ist) oder die GPIO-Nummer aus der Tabelle. Die Pinbelegung deines Boards findest du auch im Tool Pinout.
| Beschriftung | GPIO | Sonderfunktion | Hinweis |
|---|---|---|---|
| TX | GPIO 1 | UART TX (serieller Monitor) | Gibt beim Booten Daten aus; bei Serial-Nutzung frei lassen |
| RX | GPIO 3 | UART RX | Beim Booten HIGH; bei Serial-Nutzung frei lassen |
| D0 | GPIO 16 | Aufwecken aus dem Deep Sleep (an RST) | Kein PWM, keine Interrupts, kein I2C; beim Booten HIGH |
| D1 | GPIO 5 | I2C SCL | Sicher; Standardpin des Relais-Shields |
| D2 | GPIO 4 | I2C SDA | Sicher |
| D3 | GPIO 0 | FLASH, 10-kΩ-Pull-up | Bei LOW beim Booten startet der Flash-Modus |
| D4 | GPIO 2 | Onboard-LED (invertiert), 10-kΩ-Pull-up | Bei LOW beim Booten startet das Board nicht; Pin des DHT-Shields |
| D5 | GPIO 14 | SPI SCK | Sicher |
| D6 | GPIO 12 | SPI MISO | Sicher |
| D7 | GPIO 13 | SPI MOSI | Sicher |
| D8 | GPIO 15 | SPI CS, 10-kΩ-Pull-down | Bei HIGH beim Booten startet das Board nicht; CS des SD-Shields |
| A0 | ADC0 | Analogeingang | 0–3,2 V; Spannungsteiler 220 kΩ / 100 kΩ auf dem Board |
| RST | - | Reset (aktiv LOW) | Für Deep Sleep mit D0 verbunden |
| 3V3 | - | 3,3-V-Ausgang | Sensoren hier versorgen |
| 5V | - | USB-5 V / externer 5-V-Eingang | Mit USB ein Ausgang, sonst Versorgungseingang |
| G | - | GND | Gemeinsame Masse |
Kurz gesagt: Für alles sicher nutzbar sind D1, D2, D5, D6 und D7. D0 eignet sich für einfache Ausgänge und das Aufwecken aus dem Deep Sleep, kann aber kein PWM und keine Interrupts. D3 und D4 gehen für Taster (solange sie beim Booten nicht gedrückt sind) und LEDs. Alle Pins außer D0 haben einen internen Pull-up-Widerstand (INPUT_PULLUP); D0 hat nur einen internen Pull-down. Im ESP8266-Core 3.x arbeitet analogWrite() standardmäßig mit 0–255 und 1 kHz. Pro Pin sind höchstens etwa 12 mA drin; für Relais, Motoren oder lange LED-Streifen brauchst du einen Transistor oder Treiber.
Wemos D1 mini in der Arduino IDE einrichten
- Trage unter Datei > Voreinstellungen bei "Zusätzliche Boardverwalter-URLs" http://arduino.esp8266.com/stable/package_esp8266com_index.json ein; mehrere URLs trennst du mit Kommas.
- Suche im Boardverwalter nach esp8266 und installiere das Paket der ESP8266 Community.
- Wähle unter Werkzeuge > Board > ESP8266 Boards den Eintrag LOLIN(WEMOS) D1 R2 & mini.
- Erscheint kein Port, installiere den CH340-Treiber und nimm ein USB-Kabel mit Datenleitungen, kein reines Ladekabel.
- Schlägt das Hochladen mit 921600 fehl, stell Upload Speed auf 115200.
Erster Sketch: Onboard-LED blinken lassen
Die kleine blaue LED auf dem ESP-12-Modul hängt an GPIO 2 (D4) und arbeitet mit invertierter Logik: Sie leuchtet bei LOW und geht bei HIGH aus. LED_BUILTIN ist beim D1 mini als 2 definiert, deshalb läuft der folgende Code ohne Änderung:
1// D1 mini dahili LED: D4 = GPIO 2, LOW'da yanar / onboard LED: D4 = GPIO 2, lights on LOW
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT); // LED_BUILTIN = 2 (D4)
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, LOW); // LED yanar (ters mantık) / LED on (inverted logic)
8 delay(500);
9 digitalWrite(LED_BUILTIN, HIGH); // LED söner / LED off
10 delay(500);
11}Analogeingang A0: die 3,2-V-Grenze und Spannung messen
Der einzige Analog-Digital-Wandler (ADC) des ESP8266 misst eigentlich nur 0–1,0 V mit 10 Bit (0–1023). Der D1 mini setzt hinter A0 einen Spannungsteiler aus 220 kΩ und 100 kΩ: Am ADC kommt Ue × 100 / (220 + 100) an, 3,2 V an A0 erreichen den Chip also als 1,0 V. Die Formel für die Umrechnung lautet deshalb U = Rohwert × 3,2 / 1023. Für höhere Spannungen setzt du einen zusätzlichen Vorwiderstand vor A0: Mit weiteren 100 kΩ wird der obere Teil des Teilers 320 kΩ groß, und der Messbereich steigt auf 1,0 × (320 + 100) / 100 = 4,2 V – genau die Spannung eines voll geladenen Li-Ionen-Akkus. Andere Verhältnisse berechnest du mit dem Tool Spannungsteiler.
| Spannung an A0 | Am Chip | analogRead() (ca.) |
|---|---|---|
| 0 V | 0 V | 0 |
| 1,0 V | 0,31 V | 320 |
| 1,65 V | 0,52 V | 527 |
| 3,2 V | 1,0 V | 1023 |
| 3,3 V | 1,03 V | 1023 (Sättigung) |
1// A0: kartta 220k/100k bölücü, 0–3,2 V → 0–1023 / on-board 220k/100k divider, 0–3.2 V → 0–1023
2const float FULL_SCALE = 3.2; // ek 100 kΩ seri dirençle 4.2 olur / 4.2 with an extra 100 kΩ in series
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(A0);
12 delay(10); // Wi-Fi'ye zaman bırak / leave time for Wi-Fi
13 }
14 float raw = sum / 16.0;
15 float volts = raw * FULL_SCALE / 1023.0;
16 Serial.print("A0 ham / raw: ");
17 Serial.print(raw, 0);
18 Serial.print(" gerilim / voltage: ");
19 Serial.print(volts, 2);
20 Serial.println(" V");
21 delay(1000);
22}Wemos D1 mini Shields: Relais, DHT, OLED und mehr
Das Beste am D1 mini: Shields im gleichen Format lassen sich über Buchsenleisten direkt oben oder unten aufstecken. Kein Löten, keine Kabel – aber weil jedes Shield einen festen Pin belegt, musst du darauf achten, dass sich gestapelte Shields keine Pins teilen. Die gängigsten Shields und ihre Pins:
| Shield | Belegter Pin | Hinweis |
|---|---|---|
| Relais-Shield | D1 (GPIO 5) | Kontakte meist für 10 A / 250 V AC; kollidiert mit I2C-SCL |
| DHT-Shield (DHT11 oder DHT22 Pro) | D4 (GPIO 2) | Gleicher Pin wie die Onboard-LED; der Sensor nimmt Wärme vom Board auf |
| SHT30-Shield | D1, D2 (I2C) | Genauer als ein DHT; I2C-Adresse 0x45 |
| 0,66"-OLED-Shield | D1 (SCL), D2 (SDA) | 64×48 Pixel, SSD1306-Treiber, Adresse 0x3C |
| Micro-SD-Shield | D5, D6, D7, D8 (CS) | SPI; D8 muss beim Booten LOW bleiben |
| Akku-Shield (Battery) | Keine Pins | Lädt einen LiPo-Akku und versorgt das Board über den 5V-Pin |
Die Tabelle zeigt die größte Falle: Das Relais-Shield belegt standardmäßig D1, und das ist zugleich die Taktleitung von I2C. Steckst du Relais- und OLED- oder SHT30-Shield zusammen, funktioniert keins von beiden richtig. Bei manchen Relais-Shield-Versionen lässt sich der Pin über eine Lötbrücke auf der Rückseite ändern; geht das bei deinem nicht, verbinde das Relais per Kabel mit einem der Pins D5–D7. Steckst du das DHT-Shield direkt auf das Board, misst es wegen der Abwärme des ESP8266 1–3 °C zu viel; bring den Sensor mit einer Dual Base oder einem kurzen Kabel auf Abstand. Der folgende Code nutzt DHT- und Relais-Shield zusammen als einfaches Lüfterthermostat:
1#include <DHT.h>
2
3const uint8_t DHT_PIN = 2; // D4 = GPIO 2 (DHT shield)
4const uint8_t RELAY_PIN = 5; // D1 = GPIO 5 (röle shield / relay shield)
5const float ON_ABOVE = 28.0; // bunun üstünde fan açılır / fan on above this
6const float OFF_BELOW = 26.5; // bunun altında kapanır (histerezis) / off below this (hysteresis)
7
8DHT dht(DHT_PIN, DHT11); // DHT Pro shield için DHT22 / DHT22 for the DHT Pro shield
9bool fanOn = false;
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(RELAY_PIN, OUTPUT);
14 digitalWrite(RELAY_PIN, LOW); // röle kapalı başlasın / start with the relay off
15 dht.begin();
16}
17
18void loop() {
19 float t = dht.readTemperature();
20 if (!isnan(t)) { // hatalı ölçümü atla / skip failed readings
21 if (!fanOn && t > ON_ABOVE) fanOn = true;
22 if (fanOn && t < OFF_BELOW) fanOn = false;
23 digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW); // HIGH = röle çeker / HIGH = relay on
24 Serial.print(t, 1);
25 Serial.println(fanOn ? " C fan ON" : " C fan OFF");
26 }
27 delay(2000);
28}Die beiden Schwellen im Code (an bei 28 °C, aus bei 26,5 °C) bilden eine Hysterese: Mit nur einer Schwelle würde das Relais jede Sekunde klicken, wenn die Temperatur zwischen 28,0 und 28,1 pendelt, und Relais wie Lüfter verschleißen. Wie du ein Relais sicher anschließt, steht in Was ist ein Relaismodul?. Das OLED-Shield ist ein winziges SSD1306-Display mit 64×48 Pixeln; die Standardbibliothek Adafruit SSD1306 unterstützt diese Größe nicht, am einfachsten geht es mit der Bibliothek U8g2. Das Beispiel zeigt die Spannung an A0 als Zahl und als Balken:
1#include <Wire.h>
2#include <U8g2lib.h>
3
4// 0,66" OLED shield: 64×48, I2C D1 (SCL) / D2 (SDA) / 0.66" OLED shield: 64×48, I2C on D1/D2
5U8G2_SSD1306_64X48_ER_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
6
7void setup() {
8 oled.begin();
9}
10
11void loop() {
12 float volts = analogRead(A0) * 3.2 / 1023.0; // A0 → volt
13 oled.clearBuffer();
14 oled.setFont(u8g2_font_6x10_tf);
15 oled.drawStr(0, 10, "D1 mini");
16 oled.setCursor(0, 28);
17 oled.print(volts, 2);
18 oled.print(" V");
19 oled.drawFrame(0, 36, 64, 10); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 38, (int)(volts / 3.2 * 60), 6); // gerilim çubuğu / voltage bar
21 oled.sendBuffer();
22 delay(500);
23}Deep Sleep: Brücke D0–RST und Akkubetrieb
Im Deep Sleep schaltet der ESP8266 Prozessor und WLAN komplett ab; nur der interne RTC-Timer läuft weiter. Ist die Zeit um, zieht die RTC GPIO 16 (D0) kurz auf LOW. Ist D0 mit dem RST-Pin verbunden, setzt dieser Impuls den Chip zurück, und dein Code startet wieder bei setup(). Ohne die Brücke wacht das Board nie auf. Da das Aufwachen ein Neustart ist, gehen normale Variablen verloren; kleine Werte wie einen Messzähler legst du im 512 Byte großen RTC-Benutzerspeicher ab. Ein einzelner Schlaf dauert höchstens etwa 3,5 Stunden; für längere Pausen schickst du das Board mehrmals hintereinander schlafen.
| Zustand | Stromaufnahme (ca.) |
|---|---|
| Senden über WLAN | 70–170 mA |
| WLAN verbunden, im Leerlauf (Modem Sleep) | 15–20 mA |
| Light Sleep | Etwa 1 mA |
| Deep Sleep (nur der ESP8266-Chip) | Etwa 20 µA |
| Deep Sleep (komplettes D1-mini-Board) | 80–200 µA (wegen Spannungsregler und USB-Seriell-Chip) |
1// D0 (GPIO 16) ile RST arasına kablo tak / wire D0 (GPIO 16) to RST
2const uint64_t SLEEP_US = 10ULL * 60 * 1000000; // 10 dakika, mikrosaniye / 10 minutes in µs
3
4void setup() {
5 Serial.begin(115200);
6 delay(100);
7 float volts = analogRead(A0) * 3.2 / 1023.0; // ölç / measure
8 Serial.print("A0: ");
9 Serial.print(volts, 2);
10 Serial.println(" V");
11 // Wi-Fi ile gönderim burada yapılır / send the reading over Wi-Fi here
12 Serial.println("10 dk uyku / sleeping 10 min");
13 ESP.deepSleep(SLEEP_US); // uyanınca setup() baştan başlar / wakes up into setup()
14}
15
16void loop() {
17 // buraya hiç gelinmez / never reached
18}Die Akkulaufzeit kannst du grob abschätzen. Angenommen, das Board wacht alle 10 Minuten auf, zieht 5 Sekunden lang im Mittel 80 mA zum Senden und schläft die übrigen 595 Sekunden mit 0,15 mA. Pro Zyklus fallen 5 × 80 = 400 mAs und 595 × 0,15 ≈ 89 mAs an; zusammen 489 mAs, über 600 Sekunden gemittelt 0,82 mA. Ein 18650-Akku mit 2000 mAh hält damit 2000 / 0,82 ≈ 2440 Stunden, also rund 100 Tage. Mit eigenen Werten rechnest du im Tool Akkulaufzeit; das Gegenstück für den ESP32 findest du in ESP32 Deep Sleep.
Wemos D1 mini, NodeMCU oder D1 mini ESP32?
| Board | Chip | Besonderheit | Wann wählen? |
|---|---|---|---|
| Wemos D1 mini | ESP8266 | Sehr klein, Shield-System | Kleine WLAN-Sensoren, Projekte mit Shields |
| NodeMCU V3 | ESP8266 | Größer, beschriftete Pins | Bequemes Prototyping auf dem Steckbrett |
| D1 mini ESP32 (MiniKit) | ESP32-WROOM-32 | D1-mini-Raster + zusätzliche innere Pinreihe | Bluetooth, mehr ADC-Kanäle und mehr Speicher |
| LOLIN S2 mini / C3 mini | ESP32-S2 / ESP32-C3 | D1-mini-Format, Shield-kompatibel | Natives USB (S2), BLE und wenig Strom (C3) |
Beim D1 mini ESP32 passen die äußeren Pinreihen zu den D1-mini-Shields, Relais- oder OLED-Shield lassen sich also direkt aufstecken. Die D-Beschriftungen gehören beim ESP32 aber zu anderen GPIOs; die I2C-Pins sind zum Beispiel D1 = GPIO 22 und D2 = GPIO 21. Im Code nimmst du WiFi.h statt ESP8266WiFi.h und passt die Pinnummern an die Belegung des Boards an. Die ESP32-Version liest Analogwerte mit 12 Bit (0–4095), hat Bluetooth und deutlich mehr Speicher. Wenn du unsicher bist, vergleiche Was ist der ESP32? mit NodeMCU ESP8266.
Projektideen mit dem Wemos D1 mini
- WLAN-Thermometer mit Akku: Mit SHT30- oder DHT-Shield, Akku-Shield und Deep Sleep alle 10 Minuten einen Messwert senden.
- Smarte Steckdose: Mit dem Relais-Shield eine Lampe per Handy schalten; für den sicheren Anschluss den Artikel zum Relaismodul lesen.
- LED-Streifen-Steuerung: WLED aufspielen und einen WS2812B-Streifen per Handy steuern.
- Türsensor: Mit einem Reedkontakt eine Nachricht schicken, sobald die Tür aufgeht.
- Mini-Display für den Schreibtisch: Uhrzeit, Wetter oder kleine Diagramme auf dem OLED-Shield zeigen, wie auf einem größeren OLED-Display.
- Smart-Home-Sensor: Werte per MQTT an Home Assistant schicken.
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Kein Port sichtbar | CH340-Treiber fehlt oder reines Ladekabel | Treiber installieren, Datenkabel verwenden |
| Falscher Pin reagiert | Im Code steht 4 statt D4 | D-Konstanten oder die GPIO-Nummer aus der Tabelle verwenden |
| Board startet nicht, Code läuft nicht | Schaltung an D3, D4 oder D8 stört den Boot-Pegel | Schaltung auf sichere Pins (D1, D2, D5–D7) legen |
| WLAN bricht ständig ab | analogRead() ohne Pause oder schwache Versorgung | Pause zwischen Messungen, gutes 5-V-Netzteil verwenden |
| Wacht nicht aus dem Deep Sleep auf | D0 nicht mit RST verbunden | D0 per Draht, Widerstand oder Diode mit RST verbinden |
| Relais und OLED gehen nicht zusammen | Beide belegen D1 | Relais-Pin ändern oder per Kabel an einen anderen Pin legen |
| LED verhält sich umgekehrt | Onboard-LED leuchtet bei LOW | Logik umdrehen: LOW = an, HIGH = aus |
Mit seiner winzigen Größe, dem Shield-System und WLAN ist der Wemos D1 mini einer der einfachsten Einstiege in Hausautomation und Sensorprojekte. Wenn du die Pintabelle und die Boot-Regeln im Kopf behältst, läuft fast jedes ESP8266-Beispiel auf Anhieb. In der BlueGrays-App findest du bei den ESP-Projekten (LED-Blinken, WLAN-Verbindung, Webserver, OTA und Deep Sleep) Schritt-für-Schritt-Schaltpläne und Code und kannst sie mit dieser Tabelle auch auf den D1 mini übertragen, indem du die Pinnummern anpasst.
Häufige Fragen
Welcher GPIO ist D4 beim Wemos D1 mini?
D4 ist GPIO 2, und daran hängt auch die blaue Onboard-LED. Du kannst im Code pinMode(D4, OUTPUT) oder pinMode(2, OUTPUT) schreiben, pinMode(4, OUTPUT) wählt dagegen D2. Die LED arbeitet invertiert und leuchtet bei LOW.
Kann man den Wemos D1 mini mit 5 V betreiben?
Ja, das Board lässt sich über USB oder den 5V-Pin mit 5 V versorgen; der Regler auf der Platine macht daraus 3,3 V. Die GPIO-Pins arbeiten aber mit 3,3-V-Logik; Sensoren mit 5-V-Ausgang solltest du über einen Spannungsteiler oder Pegelwandler anschließen.
Welche Spannung misst der A0-Pin des Wemos D1 mini?
Dank des Spannungsteilers aus 220 kΩ und 100 kΩ auf dem Board misst A0 den Bereich 0–3,2 V als 0–1023. Der nackte ESP8266-Chip schafft nur 0–1,0 V. Mit einem zusätzlichen Vorwiderstand von 100 kΩ steigt der Bereich auf 4,2 V, genug für einen Li-Ionen-Akku.
Warum wacht mein Wemos D1 mini nicht aus dem Deep Sleep auf?
Zum Aufwachen braucht der ESP8266 den Reset-Impuls, den die RTC über D0 (GPIO 16) ausgibt. Ohne Verbindung von D0 zu RST per Draht, Widerstand von 470 Ω–1 kΩ oder Schottky-Diode bleibt das Board im Schlaf. Prüfe außerdem, dass du die Schlafzeit in Mikrosekunden angegeben hast.
Was ist der Unterschied zwischen Wemos D1 mini und NodeMCU?
Beide nutzen denselben ESP8266-Chip, und ihre Beschriftungen D0–D8 gehören zu denselben GPIOs, deshalb laufen Sketche ohne Änderung. Der D1 mini ist viel kleiner und unterstützt aufsteckbare Shields, der NodeMCU ist größer und auf dem Steckbrett bequemer.
Hat der Wemos D1 mini Bluetooth?
Nein, der ESP8266 kann nur WLAN. Brauchst du Bluetooth, nimm einen D1 mini ESP32 oder den LOLIN C3 mini mit ESP32-C3; beide haben dasselbe Format und passen zu den D1-mini-Shields.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED Blinken mit ESP32
Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

ESP32 Interne LED Blinken
Die eingebaute blaue LED auf dem ESP32 DevKit V1 zum Blinken bringen. Keine externen Komponenten erforderlich! Das erste Projekt, das Sie ausprobieren sollten, wenn Sie einen ESP32 kaufen. GPIO 2 ist mit der internen LED verbunden.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)
Du lernst, neue Firmware ohne USB-Kabel per WLAN auf den ESP32 zu laden. Mit der Bibliothek ArduinoOTA wird der ESP32 im Netzwerk sichtbar und erscheint in der Arduino IDE unter "Network port" automatisch als bluegrays-ota. Das erste Hochladen läuft über USB, danach kommen alle Updates kabellos, eine wichtige Funktion für Geräte im Außeneinsatz.

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

