Bauteile · 8 Min. Lesezeit

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.

Wemos D1 mini ESP8266 Entwicklungsboard
Wemos D1 mini: ESP-12-Modul (ESP8266, 4 MB Flash), USB-Seriell-Wandler CH340, RESET-Taster und zwei Reihen mit je 8 Pins.

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.

EigenschaftWert
ChipESP8266EX, 32 Bit, 80/160 MHz
Flash4 MB (D1 mini Pro: 16 MB)
RAM80 KB Datenspeicher (mit WLAN etwa 40–50 KB frei)
WLAN802.11 b/g/n, nur 2,4 GHz
Digitale Pins11 (D0–D8, TX, RX)
Analogeingang1 (A0, 0–3,2 V, 10 Bit)
Logikpegel3,3 V (Versorgung über USB oder den 5V-Pin)
USB-Seriell-ChipMeist CH340
Größe34,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.

BeschriftungGPIOSonderfunktionHinweis
TXGPIO 1UART TX (serieller Monitor)Gibt beim Booten Daten aus; bei Serial-Nutzung frei lassen
RXGPIO 3UART RXBeim Booten HIGH; bei Serial-Nutzung frei lassen
D0GPIO 16Aufwecken aus dem Deep Sleep (an RST)Kein PWM, keine Interrupts, kein I2C; beim Booten HIGH
D1GPIO 5I2C SCLSicher; Standardpin des Relais-Shields
D2GPIO 4I2C SDASicher
D3GPIO 0FLASH, 10-kΩ-Pull-upBei LOW beim Booten startet der Flash-Modus
D4GPIO 2Onboard-LED (invertiert), 10-kΩ-Pull-upBei LOW beim Booten startet das Board nicht; Pin des DHT-Shields
D5GPIO 14SPI SCKSicher
D6GPIO 12SPI MISOSicher
D7GPIO 13SPI MOSISicher
D8GPIO 15SPI CS, 10-kΩ-Pull-downBei HIGH beim Booten startet das Board nicht; CS des SD-Shields
A0ADC0Analogeingang0–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-AusgangSensoren hier versorgen
5V-USB-5 V / externer 5-V-EingangMit USB ein Ausgang, sonst Versorgungseingang
G-GNDGemeinsame Masse
Beim Einschalten müssen D3 (GPIO 0) und D4 (GPIO 2) HIGH und D8 (GPIO 15) LOW sein. Ein Taster an D3, der beim Einschalten gedrückt ist, ein Modul, das D4 auf LOW zieht, oder ein Sensor, der D8 auf HIGH legt, verhindern den Start: Die blaue LED bleibt dunkel, im seriellen Monitor erscheinen wirre Zeichen und dein Code läuft nie an. Nutze diese drei Pins nur mit Schaltungen, die ihren Boot-Pegel nicht verändern.

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

  1. 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.
  2. Suche im Boardverwalter nach esp8266 und installiere das Paket der ESP8266 Community.
  3. Wähle unter Werkzeuge > Board > ESP8266 Boards den Eintrag LOLIN(WEMOS) D1 R2 & mini.
  4. Erscheint kein Port, installiere den CH340-Treiber und nimm ein USB-Kabel mit Datenleitungen, kein reines Ladekabel.
  5. 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:

C++ (Arduino IDE)
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}
Im Code bewirken digitalWrite(D4, LOW) und digitalWrite(2, LOW) dasselbe, digitalWrite(4, LOW) steuert dagegen D2. Die D-Konstanten gibt es nur, wenn unter Werkzeuge > Board der D1 mini gewählt ist. Der NodeMCU nutzt dieselbe Zuordnung von Beschriftung zu GPIO, deshalb laufen Sketche auf beiden Boards unverändert.

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 A0Am ChipanalogRead() (ca.)
0 V0 V0
1,0 V0,31 V320
1,65 V0,52 V527
3,2 V1,0 V1023
3,3 V1,03 V1023 (Sättigung)
C++ (Arduino IDE)
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}
Leg an A0 nicht mehr als 3,3 V an; einen 5-V-Sensorausgang direkt anzuschließen verfälscht die Messung und kann den Chip auf Dauer schädigen. Ruft man analogRead() bei aktivem WLAN pausenlos in einer Schleife auf, kann die Verbindung abreißen; warte zwischen den Messungen mindestens ein paar Millisekunden. Steht außerdem ADC_MODE(ADC_VCC) im Code, ist A0 abgeschaltet und der ADC misst die Versorgungsspannung des Boards.

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:

ShieldBelegter PinHinweis
Relais-ShieldD1 (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-ShieldD1, D2 (I2C)Genauer als ein DHT; I2C-Adresse 0x45
0,66"-OLED-ShieldD1 (SCL), D2 (SDA)64×48 Pixel, SSD1306-Treiber, Adresse 0x3C
Micro-SD-ShieldD5, D6, D7, D8 (CS)SPI; D8 muss beim Booten LOW bleiben
Akku-Shield (Battery)Keine PinsLä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:

C++ (Arduino IDE)
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:

C++ (Arduino IDE)
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.

ZustandStromaufnahme (ca.)
Senden über WLAN70–170 mA
WLAN verbunden, im Leerlauf (Modem Sleep)15–20 mA
Light SleepEtwa 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)
C++ (Arduino IDE)
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.

Mit gesteckter D0–RST-Brücke klappt das Hochladen bei manchen Boards nicht; schlägt der Upload fehl, entferne die Brücke vorübergehend. Statt einer direkten Drahtbrücke sorgt ein Widerstand von 470 Ω–1 kΩ oder eine Schottky-Diode (Kathode an D0) dafür, dass RESET-Taster und automatisches Hochladen zuverlässig funktionieren. Nutze D0 im Deep-Sleep-Betrieb für nichts anderes.

Wemos D1 mini, NodeMCU oder D1 mini ESP32?

BoardChipBesonderheitWann wählen?
Wemos D1 miniESP8266Sehr klein, Shield-SystemKleine WLAN-Sensoren, Projekte mit Shields
NodeMCU V3ESP8266Größer, beschriftete PinsBequemes Prototyping auf dem Steckbrett
D1 mini ESP32 (MiniKit)ESP32-WROOM-32D1-mini-Raster + zusätzliche innere PinreiheBluetooth, mehr ADC-Kanäle und mehr Speicher
LOLIN S2 mini / C3 miniESP32-S2 / ESP32-C3D1-mini-Format, Shield-kompatibelNatives 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

SymptomWahrscheinliche UrsacheLösung
Kein Port sichtbarCH340-Treiber fehlt oder reines LadekabelTreiber installieren, Datenkabel verwenden
Falscher Pin reagiertIm Code steht 4 statt D4D-Konstanten oder die GPIO-Nummer aus der Tabelle verwenden
Board startet nicht, Code läuft nichtSchaltung an D3, D4 oder D8 stört den Boot-PegelSchaltung auf sichere Pins (D1, D2, D5–D7) legen
WLAN bricht ständig abanalogRead() ohne Pause oder schwache VersorgungPause zwischen Messungen, gutes 5-V-Netzteil verwenden
Wacht nicht aus dem Deep Sleep aufD0 nicht mit RST verbundenD0 per Draht, Widerstand oder Diode mit RST verbinden
Relais und OLED gehen nicht zusammenBeide belegen D1Relais-Pin ändern oder per Kabel an einen anderen Pin legen
LED verhält sich umgekehrtOnboard-LED leuchtet bei LOWLogik umdrehen: LOW = an, HIGH = aus
Startet das Board ständig neu, öffne den seriellen Monitor mit 74880 Baud. Der Bootloader des ESP8266 schreibt in dieser Geschwindigkeit die Zeilen "rst cause" und "boot mode"; rst cause:2 steht zum Beispiel für den RESET-Taster oder das Aufwachen aus dem Deep Sleep, rst cause:4 für einen Watchdog-Reset – so findest du die Ursache schnell.

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.

Alle Projekte ansehen
LED Blinken mit ESP32
ES-1Anfänger

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.

4.7(37)
108
ESP32 Interne LED Blinken
ES-4Anfänger

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.

4.8(29)
54
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

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.

4.4(21)
38
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

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.

4.8(16)
26
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

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.

4.3(10)
16
ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)
ES-30Fortgeschritten
Premium

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.

4.6(14)
22
ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
ES-29Fortgeschritten
Premium

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.

4.8(14)
23
ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
ES-37Fortgeschritten
Premium

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.

4.3(6)
11