ESP8266 Projekte: 15 Ideen mit NodeMCU und Wemos D1 mini
15 ESP8266 Projekte: WLAN-Relais, Wetterstation, Alexa, WLED, Tasmota, Sensor mit Deep Sleep; Grenzen des ESP8266, Umstieg auf ESP32 und zwei fertige Sketche.
ESP8266 Projekte nutzen das eingebaute WLAN dieses günstigen Boards, um eine Lampe per Handy zu schalten, einen Sensorwert ins Internet zu schicken oder einen LED-Streifen im Heimnetz zu steuern. Alles gilt genauso für den Wemos D1 mini, der denselben Chip trägt; die beiden Boards unterscheiden sich nur in der Größe und in ein paar Hardwaredetails. Der ESP8266 steht zwar im Schatten des ESP32, ist aber für ein einzelnes Relais, einen einzelnen Sensor oder ein kleines batteriebetriebenes Messgerät immer noch eine der günstigsten und problemlosesten Lösungen. Entscheidend ist, von Anfang an zu wissen, wo er reicht und wo ihm die Luft ausgeht.
In diesem Ratgeber haben wir 15 Projekte von leicht bis schwer mit Bauteilen, verwendeter Software und der Frage, ob der ESP8266 dafür reicht, in einer Tabelle gesammelt. Danach erklären wir Projekte wie WLAN-Relais, Alexa-Steuerung, WLED, Tasmota, ESPHome und den Batteriesensor einzeln und geben dir zwei fertige Sketche: ein Relais-Panel, das du auf dem Handy öffnest, und einen Sensor, der misst und in den Tiefschlaf geht. Nutzt du das Board zum ersten Mal, richte es zuerst mit der NodeMCU ESP8266 Anleitung ein; Details zur Pinbelegung findest du in der Anleitung zur Wemos D1 mini Pinbelegung.

NodeMCU und Wemos D1 mini: gleicher Chip, zwei Boards
Beide Boards basieren auf dem ESP8266EX mit 80 MHz (auf Wunsch 160 MHz) und 4 MB Flash, und beide werden in der Arduino IDE mit demselben Code programmiert. Der NodeMCU ist größer, seine Pinbeschriftung gut lesbar, und auf dem Steckbrett bleibt auf jeder Seite eine Reihe Löcher frei – bequem für erste Versuche. Der Wemos D1 mini ist halb so groß, und mit seinen aufsteckbaren Shields (Relais, DHT, OLED, Akku) baust du fast ohne Löten ein dauerhaftes Gerät. Bei Akkuprojekten liegt der D1 mini vorn, weil das Board im Tiefschlaf weniger Strom zieht. Schreibst du die Pins mit den Board-Bezeichnungen wie D1 und D2, läuft dasselbe Programm unverändert auf beiden Boards.
| Merkmal | NodeMCU V3 | Wemos D1 mini |
|---|---|---|
| Chip | ESP8266EX (Modul ESP-12E/F) | ESP8266EX |
| Größe | Etwa 58 × 31 mm | 34,2 × 25,6 mm |
| Nutzbare Pins | D0–D8, RX, TX, A0 | D0–D8, RX, TX, A0 |
| USB-Seriell-Chip | CH340 oder CP2102 | Meist CH340 |
| Analogeingang | A0, auf dem Board 0–3,2 V | A0, auf dem Board 0–3,2 V |
| Boardstrom im Tiefschlaf | Höher wegen Regler und USB-Chip | Etwa 80–200 µA |
| Shield-System | Keins | Relais-, DHT-, SHT30-, OLED-, SD- und Akku-Shields |
| Ideal für | Versuche auf dem Steckbrett, Lernen | Kleine Geräte im Gehäuse, Batteriesensoren |
Grenzen des ESP8266: ein Analogpin, 3,3 V und Speicher
- Nur ein Analogeingang: Der ESP8266 hat nur A0. Der Chip misst 0–1 V, der Spannungsteiler 220 kΩ / 100 kΩ auf dem Board erweitert das auf 0–3,2 V. Für einen zweiten analogen Sensor brauchst du einen I2C-ADC wie den ADS1115 oder einen ESP32. Für andere Spannungsbereiche nutze das Spannungsteiler-Tool.
- 3,3-V-Logik: Die Pins sind offiziell nicht 5-V-tolerant und sollten höchstens etwa 12 mA liefern. Das Signal von 5-V-Sensoren wie dem HC-SR04 senkst du mit einem Spannungsteiler oder Pegelwandler.
- Wenig Speicher: Bei aktivem WLAN bleiben deinem Programm etwa 40–50 KB RAM. Ein paar HTTPS-Anfragen und eine große JSON-Antwort füllen ihn schnell.
- Ein Kern und Watchdog: WLAN und dein Code teilen sich einen Kern. Eine sekundenlange Schleife in loop() oder eine lange Kette von delay() löst den Watchdog aus, und das Board startet neu; setz yield() oder kurze delay() in lange Abläufe.
- Boot-Pins: D3 (GPIO 0) und D4 (GPIO 2) müssen beim Start HIGH sein, D8 (GPIO 15) LOW. Ein Taster oder Modul an diesen Pins kann den Start verhindern; sichere Pins sind D1, D2, D5, D6 und D7.
- Kein Bluetooth: Der ESP8266 hat keine Bluetooth-Hardware. Für Bluetooth mit dem Handy oder BLE-Sensoren brauchst du einen ESP32.
| Dein Bedarf | Reicht der ESP8266? | Warum |
|---|---|---|
| WLAN-Gerät mit einem Relais oder einem Sensor | Ja | Die günstigste und ausgereifteste Lösung für solche Aufgaben |
| Batteriesensor, der ab und zu sendet | Ja | Mit Deep Sleep hält ein D1 mini monatelang |
| Mehrere analoge Sensoren | Mit externem ADC | Nur ein A0; der ESP32 hat 18 Analogkanäle |
| Bluetooth oder BLE | Nein | Keine Hardware; nimm einen ESP32 |
| Kamera | Nein | Weder Kameraschnittstelle noch PSRAM; nimm eine ESP32-CAM |
| Häufige HTTPS-Anfragen, großes JSON | Grenzwertig | Der RAM kann knapp werden; die 520 KB des ESP32 sind entspannter |
| Mehr als einige hundert adressierbare LEDs | Grenzwertig | WLED empfiehlt für lange Streifen und mehrere Ausgänge einen ESP32 |
| Touch-Pins, viele PWM-Kanäle, zwei Kerne | Nein | Diese Funktionen gibt es nur beim ESP32 |
15 NodeMCU- und ESP8266-Projekte in einer Tabelle
| # | Projekt | Bauteile | Software / Bibliothek | Niveau |
|---|---|---|---|---|
| 1 | WLAN-Relais-Panel | Relaismodul | ESP8266WebServer | Leicht |
| 2 | LED-Streifen-Dimmer per Handy | 12-V-LED-Streifen, Logic-Level-MOSFET | ESP8266WebServer, analogWrite | Leicht |
| 3 | Sprachgesteuerte Lampe mit Alexa | Relaismodul | Espalexa | Mittel |
| 4 | Türsensor mit Telegram-Meldung | Reedkontakt, Magnet | UniversalTelegramBot | Mittel |
| 5 | Adressierbare LEDs (WLED) | WS2812B-Streifen, 5-V-Netzteil | WLED (fertige Firmware) | Leicht |
| 6 | Smarte Steckdose mit Tasmota | Relaismodul | Tasmota (fertige Firmware) | Leicht |
| 7 | ESPHome-Temperatursensor | DHT22 oder BME280 | ESPHome | Leicht |
| 8 | Wetterstation mit Webseite | BME280 | ESP8266WebServer, Adafruit BME280 | Mittel |
| 9 | Batteriesensor mit Deep Sleep | DHT22, 18650-Akku | ESP8266HTTPClient, ThingSpeak | Mittel |
| 10 | Bodenfeuchte und Gießwarnung | Kapazitiver Bodenfeuchtesensor | analogRead, Telegram oder Web | Leicht |
| 11 | Uhr mit Zeit aus dem Internet | TM1637 oder OLED | NTP (configTime) | Leicht |
| 12 | Wetter- oder Wechselkursanzeige | 0,96-Zoll-OLED | ESP8266HTTPClient, ArduinoJson | Mittel |
| 13 | WLAN-IR-Universalfernbedienung | IR-LED, Transistor, IR-Empfänger | IRremoteESP8266 | Mittel |
| 14 | ESP-NOW-Funktaster | Taster, zweiter ESP8266 oder ESP32 | espnow.h | Mittel |
| 15 | Home-Assistant-Gerät über MQTT | Relais, Sensor | PubSubClient | Mittel |
Diese 15 Punkte sind Projektideen, die mit dem ESP8266 tatsächlich gebaut werden und funktionieren; zu jeder stehen Bauteile und Bibliothek in der Tabelle. Die WLAN-Projekte in der BlueGrays-App sind für den ESP32 geschrieben, behandeln aber dieselben Themen: Schaltung und Logik von ESP32 WLAN-STA-Verbindung, ESP32 Async Web Server, ESP32 mDNS, ESP32 Echtzeit per NTP aus dem Internet und ESP32 OTA-Update kannst du auf den ESP8266 übertragen; im Code ändern sich die Bibliotheksnamen (zum Beispiel ESP8266WiFi.h statt WiFi.h) und die Pinnummern.
Steuerung per WLAN (1–4): Relais, Dimmer, Alexa und Telegram
Projekt 1 ist die Grundlage der Liste: Der NodeMCU liefert eine eigene Webseite, deren Buttons ON und OFF das Relais schalten. Der Code unten macht das Board per mDNS zusätzlich unter role.local erreichbar, sodass du im Handybrowser immer dieselbe Adresse eingibst, auch wenn sich die IP ändert (manche Android-Versionen lösen .local-Namen nicht auf, dann nimm die IP). Die Adresse /state liefert den Relaiszustand als reinen Text, den ein anderes Gerät oder eine Automation abfragen kann. Projekt 2 ergänzt denselben Server um einen Helligkeitsregler: Du steuerst einen einfarbigen 12-V-LED-Streifen über einen Logic-Level-MOSFET wie den IRLZ44N, und analogWrite() des ESP8266 stellt die Helligkeit von 0 bis 255 ein.
| Verbindung | NodeMCU / D1 mini | Hinweis |
|---|---|---|
| Relaismodul IN | D1 (GPIO 5) | Beim Start sicher; bei Low-aktiven Modulen schaltet der Code mit LOW ein |
| Relaismodul VCC | VIN (5 V vom USB) | Die Relaisspule braucht 5 V |
| Relaismodul GND | GND | Gemeinsame Masse |
| Lampe (230-V-Seite) | Relaiskontakte COM und NO | Nur mit Erfahrung und in einem geschlossenen Gehäuse |
1// NodeMCU / Wemos D1 mini: telefondan Wi-Fi röle (web panel + mDNS)
2// NodeMCU / Wemos D1 mini: Wi-Fi relay from your phone (web panel + mDNS)
3#include <ESP8266WiFi.h>
4#include <ESP8266WebServer.h>
5#include <ESP8266mDNS.h>
6
7const char* WIFI_SSID = "WIFI_ADIN"; // Wi-Fi adı / Wi-Fi name
8const char* WIFI_PASS = "WIFI_SIFRESI"; // Wi-Fi şifresi / Wi-Fi password
9
10#define RELAY_PIN D1 // GPIO 5, açılışta güvenli / GPIO 5, safe at boot
11#define RELAY_ON LOW // çoğu röle modülü LOW ile çeker / most relay modules are active LOW
12#define RELAY_OFF HIGH
13
14ESP8266WebServer server(80);
15bool relayState = false;
16
17void setRelay(bool on) {
18 relayState = on;
19 digitalWrite(RELAY_PIN, on ? RELAY_ON : RELAY_OFF);
20}
21
22void handleRoot() {
23 String html = F("<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width,initial-scale=1'>"
24 "<title>Role</title><style>body{font-family:sans-serif;text-align:center;margin-top:40px}"
25 "a{display:inline-block;padding:18px 34px;margin:8px;border-radius:10px;color:#fff;text-decoration:none;font-size:22px}"
26 ".on{background:#2e7d32}.off{background:#c62828}</style></head><body><h2>Role / Relay: ");
27 html += relayState ? "ON" : "OFF";
28 html += F("</h2><a class='on' href='/on'>ON</a><a class='off' href='/off'>OFF</a></body></html>");
29 server.send(200, "text/html", html);
30}
31
32void redirectHome() {
33 server.sendHeader("Location", "/"); // yenileyince komut tekrarlanmasın / avoid repeating on refresh
34 server.send(303);
35}
36
37void setup() {
38 Serial.begin(115200);
39 pinMode(RELAY_PIN, OUTPUT);
40 setRelay(false); // açılışta kapalı / off at power-up
41
42 WiFi.mode(WIFI_STA);
43 WiFi.begin(WIFI_SSID, WIFI_PASS);
44 Serial.print("Wi-Fi");
45 while (WiFi.status() != WL_CONNECTED) {
46 delay(500);
47 Serial.print(".");
48 }
49 Serial.println();
50 Serial.print("IP: ");
51 Serial.println(WiFi.localIP());
52
53 if (MDNS.begin("role")) Serial.println("http://role.local"); // ad ile erişim / access by name
54
55 server.on("/", handleRoot);
56 server.on("/on", []() { setRelay(true); redirectHome(); });
57 server.on("/off", []() { setRelay(false); redirectHome(); });
58 server.on("/state", []() { server.send(200, "text/plain", relayState ? "ON" : "OFF"); });
59 server.begin();
60}
61
62void loop() {
63 server.handleClient();
64 MDNS.update(); // ESP8266'da mDNS için gerekli / required for mDNS on ESP8266
65}Im Code sind drei Dinge wichtig. Erstens die Definition RELAY_ON: Die meisten Relaismodule schalten bei LOW am Eingang, deshalb ist LOW voreingestellt; schaltet dein Modul mit HIGH, tausche die beiden Zeilen. Zweitens schaltet setup() das Relais zuerst aus, damit die Lampe nach einem Stromausfall nicht von selbst angeht. Drittens wird der Browser nach /on und /off mit Code 303 zur Startseite umgeleitet, sodass ein Neuladen der Seite den Befehl nicht erneut sendet. Auf dem ESP8266 braucht mDNS den Aufruf MDNS.update() in loop(); beim ESP32 ist diese Zeile nicht nötig.
In Projekt 3 lässt die Bibliothek Espalexa den NodeMCU wie eine smarte Lampe aussehen, die Alexa erkennt: Sagst du "Alexa, schalte die Wohnzimmerlampe ein", klickt das Relais. Ein zusätzliches Cloud-Konto oder ein Skill ist nicht nötig, Echo und Board müssen aber im selben lokalen Netz sein. Für Google Home kommt ein Clouddienst wie Sinric Pro ins Spiel; beide Wege vergleicht der Artikel ESP32 mit Alexa und Google Home, und beide Bibliotheken unterstützen den ESP8266. In Projekt 4 montierst du einen Reedkontakt und einen Magneten an der Tür; öffnet sich die Tür, schickt der NodeMCU über einen Telegram-Bot eine Nachricht aufs Handy. Da Telegram über HTTPS läuft, ist der Speicher in diesem Projekt die knappste Ressource des ESP8266; Nachrichten senden klappt problemlos, nur solltest du nicht gleichzeitig eine große Webseite ausliefern.
Projekte mit fertiger Firmware (5–7): WLED, Tasmota und ESPHome
Manche Projekte brauchen gar keinen Code. In Projekt 5 flashst du WLED aus dem Browser und steuerst einen WS2812B-Streifen per App mit Hunderten Effekten, Farbpaletten und Timern. Auf dem ESP8266 läuft WLED bis zu einigen hundert LEDs problemlos; für längere Streifen und mehrere Ausgänge wird ein ESP32 empfohlen. Schließ die Datenleitung über einen 330-Ω-Widerstand an und versorge den Streifen aus einem eigenen 5-V-Netzteil, nicht über das Board (WLED installieren). In Projekt 6 macht Tasmota den NodeMCU zur smarten Steckdose mit Weboberfläche, Timern, Regeln und MQTT; Tasmota wurde ursprünglich für smarte Steckdosen mit ESP8266 entwickelt. In Projekt 7 schreibst du in ESPHome ein paar YAML-Zeilen, und der Sensor erscheint von selbst in Home Assistant; als Boardname dient beim ESP8266 nodemcuv2 oder d1_mini (ESPHome einrichten).
Sensor- und Messprojekte (8–12)
In Projekt 8 wird ein BME280 an D1 (SCL) und D2 (SDA) angeschlossen; Temperatur, Luftfeuchte und Luftdruck aktualisieren sich alle paar Sekunden auf einer Webseite, die der NodeMCU ausliefert. Versorge den BME280 mit 3,3 V und prüfe mit einem I2C-Scanner, ob seine Adresse 0x76 oder 0x77 ist. Projekt 9 ist das lehrreichste der Liste: Das Board wacht auf, liest den DHT22, schickt die Werte an ThingSpeak und geht für 10 Minuten in den Tiefschlaf. Damit der ESP8266 aus dem Tiefschlaf aufwachen kann, muss D0 (GPIO 16) mit RST verbunden sein; ist die Zeit abgelaufen, gibt D0 einen kurzen LOW-Impuls und das Board startet neu. Zieh diese Brücke beim Hochladen ab, sonst kann sich das Board währenddessen selbst zurücksetzen.
1// NodeMCU + DHT22: ölç, ThingSpeak'e gönder, 10 dakika derin uyku
2// NodeMCU + DHT22: measure, send to ThingSpeak, deep sleep for 10 minutes
3// ÖNEMLİ: D0 (GPIO 16) ile RST'yi bir kabloyla bağla; yüklerken bu kabloyu çıkar
4// IMPORTANT: wire D0 (GPIO 16) to RST; remove the wire while uploading
5#include <ESP8266WiFi.h>
6#include <ESP8266HTTPClient.h>
7#include <DHT.h>
8
9const char* WIFI_SSID = "WIFI_ADIN";
10const char* WIFI_PASS = "WIFI_SIFRESI";
11const char* TS_WRITE_KEY = "WRITE_API_KEY"; // ThingSpeak kanal anahtarı / channel write key
12
13#define DHT_PIN D2 // GPIO 4
14#define SLEEP_MINUTES 10
15
16DHT dht(DHT_PIN, DHT22);
17
18void sleepNow() {
19 Serial.println("Uyku / Sleep");
20 ESP.deepSleep((uint64_t)SLEEP_MINUTES * 60ULL * 1000000ULL); // D0 -> RST darbesiyle uyanır / wakes via D0 -> RST
21}
22
23void setup() {
24 Serial.begin(115200);
25 dht.begin();
26 delay(2000); // DHT22 ilk ölçüm için hazırlansın / let the DHT22 settle
27
28 float t = dht.readTemperature();
29 float h = dht.readHumidity();
30 if (isnan(t) || isnan(h)) {
31 Serial.println("DHT okunamadi / DHT read failed");
32 sleepNow();
33 }
34
35 WiFi.mode(WIFI_STA);
36 WiFi.begin(WIFI_SSID, WIFI_PASS);
37 unsigned long t0 = millis();
38 while (WiFi.status() != WL_CONNECTED) {
39 if (millis() - t0 > 15000) sleepNow(); // 15 sn'de bağlanamazsa pili koru / give up after 15 s
40 delay(200);
41 }
42
43 WiFiClient client;
44 HTTPClient http;
45 String url = String("http://api.thingspeak.com/update?api_key=") + TS_WRITE_KEY +
46 "&field1=" + String(t, 1) + "&field2=" + String(h, 1) + "&field3=" + String(WiFi.RSSI());
47 if (http.begin(client, url)) {
48 int code = http.GET();
49 Serial.printf("HTTP %d, yanit / reply: %s\n", code, http.getString().c_str()); // 0 = reddedildi / 0 = rejected
50 http.end();
51 }
52 sleepNow();
53}
54
55void loop() {} // uyanınca setup() baştan çalışır / setup() runs again after each wakeNehmen wir für die Akkurechnung den D1 mini: Alle 10 Minuten ist das Board etwa 4 Sekunden wach und zieht im Mittel 80 mA, die übrigen 596 Sekunden schläft es mit 0,15 mA. Ein Zyklus verbraucht 4 × 80 = 320 mAs und 596 × 0,15 ≈ 89 mAs; geteilt durch 600 Sekunden ergibt das im Mittel etwa 0,68 mA, und ein 18650-Akku mit 2000 mAh hält rechnerisch über 120 Tage. Verbindet sich das WLAN nicht innerhalb von 15 Sekunden, schläft der Code ohne Senden wieder ein, damit der Akku bei ausgeschaltetem Router nicht leerläuft. ThingSpeak verlangt mindestens 15 Sekunden zwischen zwei Updates und antwortet auf regelwidrige Anfragen mit 0. Mit deinen eigenen Werten rechnest du im Akkulaufzeit-Rechner.
Projekt 10 passt am besten zum einzigen Analogpin: Du schließt einen kapazitiven Bodenfeuchtesensor an A0 an, und trocknet die Erde aus, erscheint eine Warnung auf der Webseite oder in Telegram. Mit 3,3 V versorgt, bleibt der Ausgang des Sensors im Bereich 0–3,2 V von A0; notiere die Werte in trockener und nasser Erde und leg die Schwelle dazwischen (kapazitiver Bodenfeuchtesensor). In Projekt 11 holst du mit configTime() die Uhrzeit aus dem Internet und zeigst sie auf einem TM1637 oder OLED an; mit der richtigen Zeitzone erfolgt auch die Sommerzeitumstellung automatisch. Projekt 12 lädt JSON von einem Wetter- oder Wechselkursdienst und schreibt es aufs OLED. Auf dem ESP8266 gelten dabei zwei Regeln: Wähl eine API mit kleinen Antworten und nutze in ArduinoJson einen Filter, der nur die benötigten Felder auswertet.
Kommunikationsprojekte (13–15): IR-Fernbedienung, ESP-NOW und MQTT
In Projekt 13 wurde die Bibliothek IRremoteESP8266, wie der Name sagt, für den ESP8266 geschrieben und versteht Hunderte Protokolle von Klimaanlagen-, TV- und Beamer-Fernbedienungen. Zuerst liest du mit einem IR-Empfänger die Codes deiner Fernbedienung aus, dann sendest du dieselben Codes über eine IR-LED, die ein Transistor treibt; Buttons auf einer Webseite oder Home Assistant steuern deine Geräte. In Projekt 14 überträgt ESP-NOW Nachrichten direkt zwischen zwei Boards, ganz ohne Router: Ein batteriebetriebener Taster im Garten meldet sich in Millisekunden beim NodeMCU im Haus. ESP8266 und ESP32 können sich per ESP-NOW auch gegenseitig verständigen (ESP-NOW). Projekt 15 verbindet alles: Ein NodeMCU, der sich mit PubSubClient bei MQTT anmeldet, meldet Relais und Sensor an Home Assistant (der Code im Artikel ESP32 MQTT und Home Assistant läuft mit kleinen Änderungen auch auf dem ESP8266).
Häufige Fehler bei NodeMCU-Projekten und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Board startet alle paar Sekunden neu, wdt reset im seriellen Monitor | Eine lange Schleife in loop() lässt dem WLAN keine Zeit | In lange Schleifen yield() oder delay(1) einbauen, blockierendes Warten vermeiden |
| Board wacht nie aus dem Tiefschlaf auf | Keine Verbindung zwischen D0 und RST | D0 mit RST verbinden; beim Hochladen abziehen |
| Board startet nicht, sobald ein Taster oder Modul dran ist | D3, D4 oder D8 beim Start auf falschem Pegel | Bauteil an D1, D2, D5, D6 oder D7 umstecken |
| Relais fällt nie ab | 5-V-Modul wertet das 3,3-V-HIGH-Signal nicht als aus | Modul mit 3-V-Ansteuerung, Transistortreiber oder Relais-Shield verwenden |
| A0 zeigt immer 1023 | Die Eingangsspannung liegt über 3,2 V | Bereich mit zusätzlichem Vorwiderstand erweitern, Wert mit dem Spannungsteiler-Tool berechnen |
| HTTPS-Anfrage bricht mit Speicherfehler ab | TLS-Verbindung und große Antwort füllen den RAM | API mit kleineren Antworten wählen, ArduinoJson-Filter nutzen oder auf ESP32 wechseln |
Mit welchem NodeMCU-Projekt solltest du anfangen?
- Du probierst WLAN zum ersten Mal: Bau das Relais-Panel aus Projekt 1 zuerst mit einer LED auf; läuft es, ergänze das Relais.
- Du willst Ergebnisse ohne Code: Flashe WLED oder Tasmota und versuch danach, dasselbe mit eigenem Code zu lösen.
- Du hast Home Assistant: Starte mit Projekt 7 in ESPHome und schreib MQTT dann in Projekt 15 selbst.
- Du willst ein Gerät mit Akku: Nimm für Projekt 9 einen D1 mini; sein Schlafstrom ist viel niedriger als beim NodeMCU.
- Du brauchst mehrere Analogsensoren, eine Kamera oder Bluetooth: Wechsle ohne Zeitverlust zum ESP32; die Tabelle oben zeigt, wo der ESP8266 hängen bleibt.
Im richtigen Projekt ist der ESP8266 immer noch eines der WLAN-Boards, mit denen du am schnellsten zum Ergebnis kommst: Für ein Relais, einen Sensor oder einen LED-Streifen brauchst du nicht mehr. Wachsen deine Projekte, ist der Umstieg auf den ESP32 leicht, denn die Logik von WLAN, Webserver, NTP und MQTT ist auf beiden Boards fast gleich. In der BlueGrays-App findest du ESP32-Projekte wie WLAN-Verbindung, Webserver, mDNS, NTP-Uhr, Wetter-API und Updates per OTA, jeweils mit Schaltplan, Teileliste und fertigem Code, und kannst das Gelernte auf deine NodeMCU-Projekte übertragen.
Häufige Fragen
Was kann man mit einem ESP8266 machen?
Mit einem ESP8266 oder NodeMCU baust du ein WLAN-Relais, das du per Handy schaltest, eine Lampe für Alexa, einen adressierbaren LED-Streifen mit WLED, eine smarte Steckdose mit Tasmota, eine Wetterstation, die Daten ins Internet schickt, und einen batteriebetriebenen Sensor. Dank eingebautem WLAN brauchst du kein Zusatzmodul, programmiert wird in der Arduino IDE.
Was ist der Unterschied zwischen NodeMCU und Wemos D1 mini?
Beide nutzen denselben ESP8266-Chip und denselben Code. Der NodeMCU ist größer und bequem auf dem Steckbrett; der Wemos D1 mini ist halb so groß, hat aufsteckbare Shields und zieht im Tiefschlaf weniger Strom, deshalb eignet er sich besser für Akkuprojekte.
ESP8266 oder ESP32 – was soll ich kaufen?
Für ein Relais, einen Sensor oder ein einfaches WLAN-Gerät mit Akku reicht der ESP8266 und ist günstiger. Brauchst du mehrere Analogsensoren, Bluetooth, eine Kamera, viele HTTPS-Anfragen oder lange LED-Streifen, nimm den ESP32.
Ist der ESP8266 5-V-tolerant?
Offiziell nicht: Die Pins arbeiten mit 3,3 V. Einen Sensor kannst du zwar mit 5 V versorgen, sein Ausgangssignal solltest du aber nicht direkt an einen ESP8266-Pin legen, sondern über einen Spannungsteiler oder Pegelwandler.
Warum wacht mein ESP8266 nicht aus dem Deep Sleep auf?
Damit der ESP8266 per Timer aufwacht, muss D0 (GPIO 16) mit dem RST-Pin verbunden sein; nach Ablauf der Zeit gibt D0 einen kurzen Impuls, der das Board zurücksetzt. Ohne diese Brücke bleibt das Board im Schlaf. Zieh sie beim Hochladen ab, um Uploadprobleme zu vermeiden.
Wie viele analoge Sensoren kann ein NodeMCU lesen?
Direkt nur einen, weil der ESP8266 nur einen Analogeingang (A0) hat, der auf dem Board 0–3,2 V misst. Für mehr analoge Sensoren ergänzt du ein I2C-ADC-Modul wie den ADS1115 oder wechselst zum ESP32 mit vielen Analogeingängen.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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 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: Echtzeit aus dem Internet per NTP
Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

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 HTTPClient + Wetter-API (mit LCD-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.

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.

Automatische Beleuchtung mit dem ESP32-PIR-Bewegungssensor
Ein PIR-Bewegungssensor HC-SR501 erkennt, wenn jemand den Raum betritt, und schaltet automatisch eine LED ein. millis() misst, wie lange sie leuchtet: Jedes HIGH erneuert die Zeit der letzten Bewegung, frühestens 10 Sekunden nach dem letzten HIGH geht die LED aus. Der Code wartet zudem in jeder Schleife 50 ms mit delay(50), ist also nicht ganz blockierungsfrei. Ideal für Treppen, Flure, Bäder oder Schrankbeleuchtung.
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

