ESP32 smarte Steckdose bauen: Relais, Webpanel und NTP-Timer
Baue eine WLAN-Steckdose mit dem ESP32: Relais und HLK-PM01 anschließen, Webpanel zum Schalten, NTP-Zeitplan, Lastgrenze und Sicherheitsregeln für 230 V.
Die ESP32 smarte Steckdose macht aus einer normalen Steckdose ein Gerät, das du per WLAN von Handy oder Computer ein- und ausschalten kannst und das auf Wunsch zu festen Uhrzeiten von allein läuft. Das Prinzip ist einfach: Der ESP32 verbindet sich mit deinem Heimnetz und stellt ein kleines Webpanel bereit. Drückst du dort auf "Ein", zieht der ESP32 ein Relais an, das den Phasenleiter der Steckdose schließt und das angeschlossene Gerät mit Strom versorgt. Damit der ganze Aufbau direkt aus dem Netz versorgt wird, wandelt das kleine AC-DC-Modul HLK-PM01 die 230 V in 5 V um; ein separates Netzteil im Gehäuse brauchst du also nicht.
In dieser Anleitung lernst du Schritt für Schritt, wie du die Teile auswählst, das Leistungsbudget berechnest, alles verdrahtest, den Code mit Webpanel schreibst und mit Countdown-Timer und NTP-Uhrzeit einen Tagesplan ergänzt. Das Projekt arbeitet aber mit 230 V Netzspannung und verzeiht keine Fehler. Deshalb gilt im ganzen Artikel eine Hauptregel: Teste zuerst alles mit Kleinspannung. Erst wenn Code und Verdrahtung einwandfrei laufen, gehst du unter Beachtung der Gehäuse- und Isolationsregeln ans Netz. Hast du keine Erfahrung mit Netzinstallationen, mache den letzten Schritt unbedingt unter Aufsicht einer fachkundigen Person.

Was ist eine ESP32 smarte Steckdose und wie funktioniert sie?
Auch in kommerziellen smarten Steckdosen stecken dieselben drei Blöcke: ein WLAN-Mikrocontroller, ein Schaltelement (meist ein Relais) und ein kleines Netzteil, das aus dem Netz Kleinspannung erzeugt. In unserer Version übernimmt der ESP32 WLAN, Webserver und Uhrzeit. Das Relais schaltet die 230-V-Last galvanisch getrennt vom schwachen 3,3-V-Signal des ESP32; fließt Strom durch die Spule, schließt der Kontakt, und du hörst ein deutliches "Klick". Das HLK-PM01 ist ein gekapseltes Schaltnetzteil mit Isolierung zwischen Ein- und Ausgang; es liefert aus 100–240 V AC 5 V DC bei maximal 3 W (600 mA). Zu Aufbau und Schutzbeschaltung findest du mehr im Beitrag HLK-PM01 AC-DC-Wandler.
| Bauteil | Aufgabe | Wichtiger Wert |
|---|---|---|
| ESP32 DevKit | WLAN, Webpanel, Timer und NTP-Uhr | 3,3-V-Logik, 250–350 mA Spitzenstrom beim WLAN-Senden |
| 1-Kanal-5-V-Relaismodul | Schaltet den Phasenleiter der Steckdose | Kontakt: 10 A 250 V AC (SRD-05VDC-SL-C) |
| HLK-PM01 | Wandelt 230 V AC in 5 V DC um | 5 V, 600 mA (3 W), isoliert |
| Sicherung und Varistor | Schützen den HLK-PM01-Eingang vor Kurzschluss und Überspannung | Z. B. 0,5 A träge Sicherung, 275-V-AC-Varistor (10D431K) |
| Taster | Manuelles Ein/Aus am Gehäuse | GPIO 27, interner Pull-up |
| Gehäuse und Schutzkontakt-Steckdose | Isolierung und Berührungsschutz | Flammhemmender Kunststoff UL94 V-0 |

Leistungsbudget: Reicht das HLK-PM01?
| Verbraucher | Typischer Strom (5-V-Schiene) | Hinweis |
|---|---|---|
| ESP32 (WLAN verbunden, Leerlauf) | 80–120 mA | Der Regler auf dem Board senkt 5 V auf 3,3 V |
| ESP32 (WLAN-Sendespitze) | 250–350 mA (kurzzeitig) | Mit Kondensator glätten |
| Relaisspule (5 V) | 70–90 mA | Nur solange das Relais angezogen ist |
| Status-LEDs | 5–10 mA | LEDs von Modul und Board |
| Summe (Worst Case) | Etwa 450 mA | Grenze des HLK-PM01: 600 mA |
Wie die Tabelle zeigt, passt eine smarte Steckdose mit einem Relais in die 600 mA des HLK-PM01, der Spielraum ist aber nicht groß. Setze deshalb nahe am 5V-Pin (VIN) des ESP32 einen Elko mit mindestens 470 µF und daneben einen 100-nF-Keramikkondensator ein; so bricht die Spannung bei WLAN-Spitzen und beim Anziehen des Relais nicht ein und der Controller startet nicht neu. Nutzt du ein Vierkanal-Relais und ziehst alle gleichzeitig an, liegen allein die Spulen über 300 mA; dann brauchst du ein stärkeres Modul wie das 5-W-Modell HLK-5M05. Strom und Leistung kannst du schnell mit dem Ohmschen-Gesetz-Rechner prüfen.
Schaltplan: ESP32, Relais und HLK-PM01
| Anschluss | Wird verbunden mit | Hinweis |
|---|---|---|
| HLK-PM01 AC-Eingänge | Netz L und N (nach Sicherung und Varistor) | Im Hochspannungsbereich des Gehäuses |
| HLK-PM01 +Vo | ESP32 5V (VIN) und Relaismodul VCC | Beim Programmieren vom Netz trennen |
| HLK-PM01 -Vo | ESP32 GND und Relaismodul GND | Gemeinsame Masse |
| Relais IN | ESP32 GPIO 26 | Sicherer Pin, der beim Start kein Signal erzeugt |
| Taster | GPIO 27 und GND | INPUT_PULLUP, kein externer Widerstand nötig |
| Status-LED | GPIO 2 | Bei den meisten DevKit-Boards integriert |
| Relais COM | Netzphase (L), nach der Sicherung | Nur die Phase wird unterbrochen |
| Relais NO | Phasenanschluss der Steckdose | Normalerweise offen: Lässt das Relais los, ist die Steckdose spannungsfrei |
| Neutralleiter (N) und Schutzleiter (PE) | Direkt zu den N- und PE-Anschlüssen der Steckdose | Laufen nicht über das Relais, sondern durchgehend |
Für das Relais haben wir GPIO 26 aus gutem Grund gewählt: GPIO 0, 2, 12 und 15 sind Strapping-Pins und beeinflussen den Start des Boards; GPIO 1 und 3 gehören zur seriellen Schnittstelle, 6–11 zum internen Flash, und GPIO 5 und 14 erzeugen beim Start kurze Signale. GPIO 26 macht nichts davon. GPIO 2 ist unkritisch, weil er nur die Board-LED ansteuert. Wichtig ist auch der NO-Kontakt (normally open) des Relais: Ist der ESP32 aus, startet neu oder fällt aus, lässt das Relais los und die Steckdose bleibt spannungsfrei. Mit dem NC-Kontakt wäre es umgekehrt, und bei einer Störung würde das Gerät dauerhaft laufen.
Erst mit Kleinspannung testen
- Versorge den ESP32 nur über das USB-Kabel; das HLK-PM01 schließt du in dieser Phase gar nicht an. Verbinde VCC des Relaismoduls mit dem 5V-Pin (VIN) des ESP32, GND mit GND und IN mit GPIO 26.
- Schließe an COM und NO des Relais statt 230 V eine Last mit Kleinspannung an: Ein 12-V-Netzteil mit einem kurzen LED-Streifen oder eine mit 5 V betriebene LED mit 220-Ω-Widerstand genügt.
- Lade den folgenden Testcode hoch und öffne den Serial Monitor mit 115200 Baud; das Relais sollte alle 2 Sekunden klicken und die LED blinken.
- Arbeitet das Relais verkehrt herum (die Last geht aus, obwohl "ACIK" angezeigt wird), ändere im Code den Wert von RELAY_ACTIVE_LOW.
- Lade danach den Code mit Webpanel hoch, schalte per Handy ein und aus und probiere den Timer aus; prüfe, dass das Relais nach einem Reset des ESP32 ausgeschaltet startet und das Board nicht einfriert, wenn das WLAN wegfällt.
- Lass den Aufbau einen Tag lang mit Kleinspannung laufen und kontrolliere, dass der NTP-Zeitplan zur richtigen Uhrzeit ein- und ausschaltet; erst danach gehst du zum Netzaufbau über.
1// Röle testi / Relay test
2const int RELAY_PIN = 26; // Röle IN pini / Relay IN pin
3const bool RELAY_ACTIVE_LOW = true; // Çoğu modül LOW ile çeker / Most modules energize on LOW
4
5void relaySet(bool on) {
6 if (RELAY_ACTIVE_LOW) digitalWrite(RELAY_PIN, on ? LOW : HIGH);
7 else digitalWrite(RELAY_PIN, on ? HIGH : LOW);
8}
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(RELAY_PIN, OUTPUT);
13 relaySet(false); // kapalı başla / start off
14}
15
16void loop() {
17 relaySet(true);
18 Serial.println("Role ACIK / Relay ON");
19 delay(2000);
20 relaySet(false);
21 Serial.println("Role KAPALI / Relay OFF");
22 delay(2000);
23}Die Funktion relaySet() übersetzt die Befehle "ein" und "aus" in die Triggerlogik des Moduls. Die meisten Relaismodule auf dem Markt sind LOW-getriggert: Wird der IN-Pin auf GND gezogen, zieht das Relais an. Statt diese umgekehrte Logik im ganzen Code mitzudenken, steuerst du sie über eine einzige Konstante (RELAY_ACTIVE_LOW) und vermeidest Fehler. Ein Vorteil: Beim Start und Reset des ESP32 sind die Pins Eingänge, und ein LOW-getriggertes Modul mit offenem IN-Pin zieht in dieser Zeit nicht von selbst an. Zu Aufbau und Treiberschaltung des Relais schau in Was ist ein Relaismodul?.
Code für die smarte Steckdose mit Webpanel
Wenn der Test geklappt hat, kannst du zum eigentlichen Code übergehen. Die mit dem ESP32-Arduino-Core mitgelieferte Bibliothek WebServer braucht keine zusätzliche Installation und funktioniert in den Core-Versionen 2.x und 3.x gleich. Der Code liefert auf der Startseite ein Bedienpanel, die Befehle unter /on, /off, /toggle und /timer?min=30 und unter /state den Zustand der Steckdose als JSON. Das Panel fragt /state alle 2 Sekunden ab; so siehst du auf dem Handy auch Änderungen per Taster am Gehäuse oder per Zeitplan. Vergiss nicht, WLAN-Name und Passwort am Anfang des Codes an dein Netz anzupassen; der ESP32 verbindet sich nur mit 2,4-GHz-Netzen. Für Updates in Echtzeit lies ESP32 Webserver und WebSocket.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESPmDNS.h>
4#include <time.h>
5
6const char* WIFI_SSID = "WIFI_ADI"; // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "WIFI_SIFRESI"; // Wi-Fi şifren / your Wi-Fi password
8
9const int RELAY_PIN = 26; // Röle IN / Relay IN
10const int BUTTON_PIN = 27; // Yerel buton / Local button
11const int LED_PIN = 2; // Durum LED'i / Status LED
12const bool RELAY_ACTIVE_LOW = true; // LOW tetiklemeli modül / Active-LOW module
13
14// Günlük program (gece yarısından itibaren dakika) / Daily schedule (minutes after midnight)
15int onMinute = 18 * 60 + 30; // 18:30 aç / turn on
16int offMinute = 23 * 60; // 23:00 kapat / turn off
17bool scheduleEnabled = true;
18
19WebServer server(80);
20bool relayOn = false;
21bool timerActive = false;
22unsigned long offAtMs = 0;
23int lastCheckedMinute = -1;
24
25const char PAGE[] PROGMEM = R"rawliteral(
26<!DOCTYPE html><html><head><meta charset="utf-8">
27<meta name="viewport" content="width=device-width,initial-scale=1">
28<title>Akıllı Priz</title>
29<style>
30body{font-family:sans-serif;text-align:center;background:#0f172a;color:#e2e8f0}
31button{font-size:20px;margin:6px;padding:12px 22px;border:0;border-radius:10px;color:#fff}
32.on{background:#16a34a}.off{background:#dc2626}.t{background:#2563eb}
33</style></head><body>
34<h2>ESP32 Akıllı Priz</h2>
35<p id="s">...</p><p id="z"></p>
36<button class="on" onclick="go('/on')">AÇ</button>
37<button class="off" onclick="go('/off')">KAPAT</button><br>
38<button class="t" onclick="go('/timer?min=15')">15 dk</button>
39<button class="t" onclick="go('/timer?min=30')">30 dk</button>
40<button class="t" onclick="go('/timer?min=60')">60 dk</button>
41<script>
42function show(d){
43 document.getElementById('s').textContent='Priz: '+(d.on?'AÇIK':'KAPALI');
44 document.getElementById('z').textContent='Saat '+d.time+(d.left>0?' | Kalan: '+d.left+' dk':'');
45}
46function go(u){fetch(u).then(r=>r.json()).then(show);}
47setInterval(()=>go('/state'),2000);
48go('/state');
49</script></body></html>
50)rawliteral";
51
52void relaySet(bool on) {
53 relayOn = on;
54 if (RELAY_ACTIVE_LOW) digitalWrite(RELAY_PIN, on ? LOW : HIGH);
55 else digitalWrite(RELAY_PIN, on ? HIGH : LOW);
56 digitalWrite(LED_PIN, on ? HIGH : LOW);
57}
58
59String timeText() {
60 struct tm t;
61 if (!getLocalTime(&t, 10)) return "--:--"; // saat henüz yok / time not synced yet
62 char buf[16];
63 snprintf(buf, sizeof(buf), "%02d:%02d", t.tm_hour, t.tm_min);
64 return String(buf);
65}
66
67long minutesLeft() {
68 if (!timerActive) return 0;
69 long ms = (long)(offAtMs - millis());
70 return ms > 0 ? (ms + 59999L) / 60000L : 0;
71}
72
73void sendState() {
74 String json = "{\"on\":";
75 json += relayOn ? "true" : "false";
76 json += ",\"time\":\"";
77 json += timeText();
78 json += "\",\"left\":";
79 json += String(minutesLeft());
80 json += "}";
81 server.send(200, "application/json", json);
82}
83
84void handleOn() { timerActive = false; relaySet(true); sendState(); }
85void handleOff() { timerActive = false; relaySet(false); sendState(); }
86
87void handleTimer() {
88 int m = server.arg("min").toInt();
89 if (m < 1 || m > 720) { // 1-720 dakika / 1-720 minutes
90 server.send(400, "text/plain", "min 1-720");
91 return;
92 }
93 relaySet(true);
94 offAtMs = millis() + (unsigned long)m * 60000UL;
95 timerActive = true;
96 sendState();
97}
98
99void setup() {
100 Serial.begin(115200);
101 pinMode(RELAY_PIN, OUTPUT);
102 pinMode(LED_PIN, OUTPUT);
103 pinMode(BUTTON_PIN, INPUT_PULLUP);
104 relaySet(false); // güvenli başlangıç: kapalı / safe start: off
105
106 WiFi.mode(WIFI_STA);
107 WiFi.setAutoReconnect(true);
108 WiFi.begin(WIFI_SSID, WIFI_PASS);
109 unsigned long t0 = millis();
110 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 20000) {
111 delay(500);
112 Serial.print(".");
113 }
114 Serial.println();
115 Serial.print("IP: ");
116 Serial.println(WiFi.localIP());
117
118 configTzTime("<+03>-3", "pool.ntp.org", "time.google.com"); // Türkiye UTC+3 / Turkey UTC+3
119
120 if (MDNS.begin("akillipriz")) {
121 Serial.println("http://akillipriz.local");
122 }
123
124 server.on("/", []() { server.send(200, "text/html; charset=utf-8", PAGE); });
125 server.on("/state", sendState);
126 server.on("/on", handleOn);
127 server.on("/off", handleOff);
128 server.on("/toggle", []() { timerActive = false; relaySet(!relayOn); sendState(); });
129 server.on("/timer", handleTimer);
130 server.begin();
131}
132
133void loop() {
134 server.handleClient();
135
136 // Yerel buton, basit debounce / Local button, simple debounce
137 static bool lastBtn = HIGH;
138 static unsigned long lastChange = 0;
139 bool btn = digitalRead(BUTTON_PIN);
140 if (btn != lastBtn && millis() - lastChange > 50) {
141 lastChange = millis();
142 lastBtn = btn;
143 if (btn == LOW) { // basıldı / pressed
144 timerActive = false;
145 relaySet(!relayOn);
146 }
147 }
148
149 // Geri sayım zamanlayıcısı / Countdown timer
150 if (timerActive && (long)(millis() - offAtMs) >= 0) {
151 timerActive = false;
152 relaySet(false);
153 }
154
155 // NTP saatine göre günlük program / Daily schedule from NTP time
156 static unsigned long lastTick = 0;
157 if (millis() - lastTick >= 1000) {
158 lastTick = millis();
159 struct tm t;
160 if (scheduleEnabled && getLocalTime(&t, 0)) {
161 int nowMin = t.tm_hour * 60 + t.tm_min;
162 if (nowMin != lastCheckedMinute) { // her dakika bir kez / once per minute
163 lastCheckedMinute = nowMin;
164 if (nowMin == onMinute) relaySet(true);
165 if (nowMin == offMinute) { timerActive = false; relaySet(false); }
166 }
167 }
168 }
169}| Codeteil | Was er macht |
|---|---|
| relaySet(bool on) | Aktualisiert Relais, Status-LED und die Variable relayOn gemeinsam |
| server.on("/timer", ...) | Schaltet die Steckdose mit einem Parameter wie ?min=30 ein und nach Ablauf der Zeit wieder aus (1–720 Minuten) |
| minutesLeft() | Berechnet die Restzeit des Timers in Minuten, aufgerundet |
| (long)(millis() - offAtMs) >= 0 | Zeitvergleich, der den Überlauf von millis() (nach etwa 49,7 Tagen) übersteht |
| configTzTime("<+03>-3", ...) | Holt die Zeit von NTP-Servern und rechnet sie in die türkische Zeit (UTC+3) um |
| lastCheckedMinute | Sorgt dafür, dass der Zeitplan nur einmal pro Minute geprüft wird; dein manueller Befehl wird nicht überschrieben |
| MDNS.begin("akillipriz") | Erlaubt dir, das Panel statt per IP über http://akillipriz.local aufzurufen |
Automatischer Betrieb mit Timer und NTP
Der ESP32 hat keine batteriegepufferte Uhr; beim Einschalten kennt er die Uhrzeit nicht. Der Aufruf configTzTime() startet im Hintergrund den SNTP-Client, holt die UTC-Zeit von Servern wie pool.ntp.org und rechnet sie anhand des angegebenen Zeitzonen-Strings in Ortszeit um. Nach dem ersten Abruf zählt der ESP32 mit seinem eigenen Timer weiter und gleicht sich standardmäßig stündlich neu ab. Da die Türkei seit 2016 keine Sommerzeit mehr nutzt, genügt der String "<+03>-3"; im POSIX-Format wird das Vorzeichen umgekehrt geschrieben, daher erscheint UTC+3 als -3. Details findest du im Beitrag ESP32 Internetzeit mit NTP.
Im Code gibt es zwei Arten des automatischen Betriebs. Erstens den Countdown-Timer: Die Schaltfläche "30 dk" im Panel schaltet die Steckdose ein und nach Ablauf der Zeit wieder aus; ideal für Geräte wie Ladegerät, Aquarium-Belüfter oder Raumventilator, die du nicht versehentlich anlassen willst. Zweitens den Tagesplan: Die Steckdose schaltet täglich zur Zeit onMinute ein und zur Zeit offMinute aus. Weil der Plan nur im Moment des Minutenwechsels und genau in dieser Minute eingreift, bleibt eine Lampe, die du um 20:00 von Hand ausgeschaltet hast, bis zur nächsten Einschaltzeit aus. Aus demselben Grund funktionieren auch Pläne über Mitternacht, etwa Einschalten um 22:00 und Ausschalten um 06:00, problemlos.
| Einstellung | Beispielwert | Ergebnis |
|---|---|---|
| onMinute | 18 * 60 + 30 | Schaltet täglich um 18:30 ein |
| offMinute | 23 * 60 | Schaltet täglich um 23:00 aus |
| onMinute und offMinute | 7 * 60 und 21 * 60 | Aquarium- oder Pflanzenlampe leuchtet von 07:00 bis 21:00 |
| scheduleEnabled | false | Tagesplan deaktiviert; nur Panel, Taster und Countdown arbeiten |
| Zeitzone in configTzTime | "CET-1CEST,M3.5.0,M10.5.0/3" | Mitteleuropäische Zeit, mit Sommerzeitumstellung |
Lastgrenze: Was darfst du anschließen?
Den Strom eines Geräts berechnest du mit der Formel I = P / V: Ein 1000-W-Gerät zieht bei 230 V 1000 / 230 ≈ 4,3 A. Dass auf dem Relais "10A 250VAC" steht, heißt nicht, dass das Modul dauerhaft 10 A tragen kann; bei billigen Modulen erwärmen sich Leiterbahnen, Schraubklemmen und das Relais selbst bei diesem Strom. Außerdem ziehen Geräte mit Motor oder Kompressor im ersten Moment ein Vielfaches ihres Betriebsstroms, und die Kontakte bilden bei jedem Schalten einen Lichtbogen. Halte die Dauerlast als sichere Praxisgrenze unter 2–3 A (etwa 500–700 W). Details zur Leistungsberechnung findest du in Elektrische Leistung berechnen.
| Gerät | Typische Leistung | Strom (230 V) | Für diese Steckdose |
|---|---|---|---|
| LED-Lampe | 9–12 W | 0,04–0,05 A | Geeignet |
| Router / Modem | 10–15 W | 0,04–0,07 A | Geeignet (ideal für Neustart aus der Ferne) |
| Handy- und Laptop-Ladegerät | 20–65 W | 0,09–0,28 A | Geeignet |
| Tischventilator | 40–60 W | 0,17–0,26 A | Geeignet (induktive Last, Kontakt verschleißt schneller) |
| Aquarium-Heizer | 100–200 W | 0,43–0,87 A | Geeignet |
| Kaffeemaschine | 1000–1500 W | 4,3–6,5 A | Nicht empfohlen |
| Wasserkocher, Bügeleisen, Heizlüfter | 2000–2400 W | 8,7–10,4 A | Auf keinen Fall |
Gehäuse und Netzsicherheit
- Die Phase wird unterbrochen, nicht der Neutralleiter: Das Relais gehört immer in den Phasenleiter (L). Unterbrichst du den Neutralleiter, liegt im Gerät auch bei ausgeschalteter Steckdose Phase an, und die Berührungsgefahr bleibt.
- Schutzleiter durchgehend: Der Schutzkontakt der Steckdose wird direkt mit dem Schutzleiter der Zuleitung verbunden; er läuft weder über das Relais noch über die Platine.
- Bereiche trennen: 230-V-Leitungen, Relaiskontakte und der HLK-PM01-Eingang gehören auf eine Seite des Gehäuses, ESP32 und 5-V-Leitungen auf die andere. Lass zwischen beiden Bereichen mindestens 6 mm Abstand und setze bei Bedarf eine Trennwand aus Kunststoff ein.
- Richtiges Kabel und richtige Klemmen: Verwende auf der Netzseite mindestens 1,5 mm² flexible Leitung mit Aderendhülsen und solide Klemmen. Jumperkabel und Breadboard haben auf der Netzseite nichts verloren.
- Sicherung: Setze in die Lastleitung eine Sicherung, die kleiner als die Grenze des Relais ist (zum Beispiel 5 A), und in den HLK-PM01-Eingang eine eigene kleine Sicherung.
- Gehäuse: Wähle ein flammhemmendes Projektgehäuse aus Kunststoff (UL94 V-0); bei einem Metallgehäuse muss es unbedingt geerdet werden. Befestige das Zuleitungskabel mit einer Kabelverschraubung oder Zugentlastung, damit es sich beim Ziehen nicht aus den Klemmen löst.
- Programm aktualisieren: Steck kein USB-Kabel an und öffne den Deckel nicht, solange das Gehäuse am Netz hängt. Für kabellose Updates kannst du die Methode ESP32 OTA-Update ergänzen.
- Erste Spannung: Miss die Leitungen vor dem ersten Anschluss ans Netz mit dem Multimeter auf Kurzschluss durch und mach den ersten Versuch an einem mit FI-Schutzschalter gesicherten Stromkreis mit einer kleinen LED-Lampe.
Projektideen und Erweiterungen
- An die Hausautomation anbinden: Binde die Steckdose über MQTT und Home Assistant in deine anderen smarten Geräte und Automationen ein.
- Von außerhalb steuern: Mit einem Telegram-Bot schaltest du die Steckdose von überall, ohne einen Port im Router zu öffnen.
- Passwort aus dem Code holen: Mit WiFiManager gibst du die WLAN-Daten beim ersten Start am Handy ein; beim Netzwechsel musst du den Code nicht neu hochladen.
- Thermostat-Steckdose: Ergänze einen DHT11 oder DS18B20 und schalte Heizer oder Lüfter nach Temperatur.
- Lautloses Schalten: Willst du kein Klicken und keinen Kontaktverschleiß, nimm bei ohmschen Lasten ein Halbleiterrelais (SSR).
- Bewegungsgesteuerte Steckdose: Baue mit einem PIR-Sensor eine Schaltung, die beim Betreten des Raums die Lampe einschaltet und nach 5 Minuten ohne Bewegung wieder ausschaltet.
- Pico-W-Version: Willst du dieselbe Idee mit MicroPython ausprobieren, starte mit dem Beitrag Pico-W-Webserver.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Relais fällt nie ab | LOW-getriggertes Modul mit 5-V-Versorgung schaltet bei 3,3 V HIGH nicht ganz ab | JD-VCC trennen oder ein Modul mit 3,3-V-Triggerung verwenden |
| ESP32 startet neu, wenn das Relais anzieht | Spannungseinbruch (Brownout) oder Störungen durch Kontaktlichtbogen | 470 µF und 100 nF an die 5V-Schiene setzen, Kabel kürzen |
| Panel lässt sich nicht öffnen | Handy in anderem Netz, IP hat sich geändert oder ESP32 ist nicht im WLAN | IP im Serial Monitor prüfen, feste IP vergeben |
| Uhrzeit zeigt "--:--" | NTP-Server nicht erreichbar | Internetverbindung und DNS prüfen, zweiten Server ergänzen |
| Zeitplan läuft 3 Stunden verschoben | Keine Zeitzone angegeben, es gilt UTC | Mit configTzTime den richtigen Zeitzonen-String setzen |
| Relais zieht beim Start kurz an | Strapping-Pin wie GPIO 0, 2, 12, 15 gewählt oder Modul ist HIGH-getriggert | Sicheren Pin wie GPIO 26 verwenden, Modultyp prüfen |
| Relais und Klemmen werden heiß | Die Last ist zu groß für das Modul | Last unter 2–3 A senken, für große Lasten ein Schütz nehmen |
Die ESP32 smarte Steckdose ist ein sehr lehrreiches Projekt, weil sie WLAN, Webserver, Zeitverwaltung und Leistungselektronik vereint. Wenn du in der richtigen Reihenfolge und mit Geduld vorgehst, erhältst du ein Gerät, das kommerziellen Produkten ähnelt und komplett von dir kontrolliert wird. In der BlueGrays-App kannst du dir ESP32-Webserver, NTP-Uhr, mDNS und Beleuchtungsprojekte mit Relais samt Schaltplänen und fertigem Code Schritt für Schritt ansehen und die Steckdose weiter ausbauen.
Häufige Fragen
Ist es sicher, mit dem ESP32 eine smarte Steckdose zu bauen?
Die Kleinspannungsseite (ESP32, Relaisspule und Code) ist völlig ungefährlich; das eigentliche Risiko liegt auf der 230-V-Seite. Grundregeln sind: die Phase mit dem Relais unterbrechen, den Schutzleiter durchgehend lassen, Sicherungen verwenden und alles in ein geschlossenes, flammhemmendes Gehäuse einbauen. Hast du keine Erfahrung, teste zuerst mit einer 12-V-Last und lass den Netzanschluss von jemandem prüfen, der sich damit auskennt.
Versorgt das HLK-PM01 ESP32 und Relais gleichzeitig?
Ja, für eine Schaltung mit einem Relais reicht es. Das HLK-PM01 liefert 600 mA bei 5 V; der ESP32 zieht im Schnitt 80–120 mA, bei WLAN-Spitzen etwa 300 mA, die Relaisspule 70–90 mA. Setze zum Glätten von Spannungsschwankungen einen 470-µF-Kondensator an die 5-V-Schiene; bei mehreren Relais nimm ein 5-W-Modul wie das HLK-5M05.
Kann der ESP32 ein 5-V-Relaismodul ansteuern?
Die meisten Module mit Transistortreiber lassen sich mit dem 3,3-V-Ausgang des ESP32 problemlos schalten; die Spule wird mit 5 V versorgt, und vom ESP32-Pin fließen nur wenige Milliampere. Bei Modulen mit Optokoppler und LOW-Triggerung kann der 3,3-V-HIGH-Pegel das Relais aber nicht ganz loslassen. Entferne dann den JD-VCC-Jumper, lege VCC an 3V3 und JD-VCC an 5 V.
Was macht die smarte Steckdose, wenn der Strom ausfällt und wiederkommt?
Der Code in diesem Beitrag startet das Relais aus Sicherheitsgründen bei jedem Start ausgeschaltet. Soll sie sich an den letzten Zustand erinnern, speichere ihn mit der Preferences-Bibliothek im Flash und stelle ihn in setup() wieder her. Die NTP-Zeit wird wenige Sekunden nach Rückkehr der Internetverbindung neu geholt, und der Tagesplan läuft dort weiter, wo er war.
Kann ich die smarte Steckdose von außerhalb über das Internet steuern?
Auf das Webpanel dieses Codes kommst du nur aus dem lokalen Heimnetz. Für die Steuerung von außen ist ein Dienst wie Telegram-Bot, MQTT, Blynk oder Firebase einfacher und sicherer, als einen Port am Router zu öffnen. Da sich der ESP32 selbst mit diesen Diensten verbindet, öffnest du dein Heimnetz nicht von außen.
Wie viel Watt darf ich an die ESP32 smarte Steckdose anschließen?
Auch wenn auf Hobby-Relaismodulen 10 A steht, ist es sicher, die Dauerlast unter 2–3 A zu halten, bei 230 V also unter etwa 500–700 W. Lampen, Ladegeräte, Router, Ventilatoren und Aquarium-Zubehör sind geeignet. Leistungsstarke Geräte wie Wasserkocher, Bügeleisen, Heizlüfter und Klimaanlagen dürfen nicht an dieses Projekt.
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 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: 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-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-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

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.

220-V-Glühbirne mit Fernbedienung schalten
Schalte eine echte Glühbirne in deiner Wohnung mit einer Fernbedienung ein und aus, ohne vom Sofa aufzustehen.
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

