Presa intelligente ESP32: relè, pannello web e timer NTP
Costruisci una presa intelligente ESP32 Wi-Fi: relè e HLK-PM01, pannello web on/off, timer con orario NTP, limite di carico e regole di sicurezza a 230 V.
La presa intelligente ESP32 trasforma una normale presa in un dispositivo che puoi accendere e spegnere via Wi-Fi dal telefono o dal computer e, se vuoi, far funzionare da solo a orari prestabiliti. Il principio è semplice: l'ESP32 si collega alla rete di casa e pubblica un piccolo pannello web; quando premi "Accendi", l'ESP32 eccita un relè, che chiude la linea di fase della presa e alimenta il dispositivo collegato. Per alimentare il tutto dalla rete, un minuscolo modulo AC-DC chiamato HLK-PM01 converte i 230 V in 5 V, così dentro la scatola non serve un alimentatore separato.
In questa guida vedrai passo dopo passo come scegliere i componenti, calcolare il bilancio di potenza, fare i collegamenti, scrivere il codice con pannello web e aggiungere un timer a conto alla rovescia e un programma giornaliero con l'orario NTP. Attenzione però: questo progetto lavora con la tensione di rete a 230 V e non perdona gli errori. Per questo in tutto l'articolo c'è una sola regola fondamentale: prova tutto prima a bassa tensione; quando codice e collegamenti funzionano alla perfezione, passa alla rete rispettando le regole di isolamento e di chiusura nella scatola. Se non hai esperienza con gli impianti di rete, fai l'ultimo passaggio sotto la supervisione di una persona esperta.

Che cos'è una presa intelligente ESP32 e come funziona?
Anche le prese intelligenti commerciali contengono gli stessi tre blocchi: un microcontrollore Wi-Fi, un elemento di commutazione (di solito un relè) e un piccolo alimentatore che ricava una bassa tensione dalla rete. Nella nostra versione l'ESP32 gestisce la connessione Wi-Fi, il server web e l'orologio. Il relè commuta il carico a 230 V con il debole segnale a 3,3 V dell'ESP32 mantenendo i due circuiti isolati elettricamente; quando la bobina riceve corrente il contatto interno si chiude e lo senti dal "clic" udibile. L'HLK-PM01 è invece un alimentatore switching in contenitore chiuso, con ingresso e uscita isolati: da un ingresso 100–240 V AC fornisce 5 V DC e al massimo 3 W (600 mA). Per la struttura interna e il circuito di protezione del modulo guarda l'articolo sul convertitore AC-DC HLK-PM01.
| Componente | Funzione | Valore importante |
|---|---|---|
| ESP32 DevKit | Wi-Fi, pannello web, timer e orologio NTP | Logica a 3,3 V, picco di 250–350 mA in trasmissione Wi-Fi |
| Modulo relè a 1 canale 5 V | Apre e chiude la linea di fase della presa | Contatti: 10 A 250 V AC (SRD-05VDC-SL-C) |
| HLK-PM01 | Converte 230 V AC in 5 V DC | 5 V, 600 mA (3 W), isolato |
| Fusibile e varistore | Proteggono l'ingresso dell'HLK-PM01 da corto circuito e sovratensioni | Ad esempio fusibile ritardato da 0,5 A, varistore 275 V AC (10D431K) |
| Pulsante | Accensione/spegnimento manuale dalla scatola | GPIO 27, pull-up interno |
| Scatola di progetto e presa con terra | Isolamento e sicurezza al contatto | Plastica autoestinguente UL94 V-0 |

Bilancio di potenza: l'HLK-PM01 basta?
| Consumatore | Corrente tipica (linea 5 V) | Nota |
|---|---|---|
| ESP32 (Wi-Fi connesso, a riposo) | 80–120 mA | Il regolatore sulla scheda abbassa 5 V a 3,3 V |
| ESP32 (picco di trasmissione Wi-Fi) | 250–350 mA (brevi istanti) | Va livellato con un condensatore |
| Bobina del relè (5 V) | 70–90 mA | Solo quando il relè è eccitato |
| LED di stato | 5–10 mA | LED del modulo e della scheda |
| Totale (caso peggiore) | Circa 450 mA | Limite dell'HLK-PM01: 600 mA |
Come vedi dalla tabella, una presa intelligente con un solo relè rientra nei 600 mA dell'HLK-PM01, ma il margine non è ampio. Per questo conviene mettere vicino al pin 5V (VIN) dell'ESP32 un condensatore elettrolitico da almeno 470 µF e accanto uno ceramico da 100 nF: evitano che la tensione scenda e la scheda si resetti durante i picchi di corrente del Wi-Fi e nell'istante in cui il relè scatta. Se usi un relè a quattro canali e li eccita tutti insieme, le sole bobine superano i 300 mA; in quel caso scegli un modulo più potente, come l'HLK-5M05 da 5 W. Puoi controllare rapidamente corrente e potenza con il calcolatore della legge di Ohm.
Schema di collegamento: ESP32, relè e HLK-PM01
| Terminale | Dove si collega | Nota |
|---|---|---|
| Ingressi AC dell'HLK-PM01 | L e N di rete (dopo fusibile e varistore) | Nello scomparto ad alta tensione della scatola |
| HLK-PM01 +Vo | ESP32 5V (VIN) e VCC del modulo relè | Scollega la rete quando carichi il programma |
| HLK-PM01 -Vo | GND dell'ESP32 e GND del modulo relè | Massa comune |
| IN del relè | ESP32 GPIO 26 | Pin sicuro che non genera segnali all'avvio |
| Pulsante | GPIO 27 e GND | INPUT_PULLUP, nessuna resistenza esterna |
| LED di stato | GPIO 2 | Integrato sulla maggior parte delle schede DevKit |
| COM del relè | Fase di rete (L), dopo il fusibile | Si interrompe solo la fase |
| NO del relè | Contatto di fase della presa | Normalmente aperto: se il relè si diseccita la presa resta senza tensione |
| Neutro (N) e terra (PE) | Direttamente ai contatti N e terra della presa | Non passano dal relè, proseguono senza interruzioni |
Abbiamo scelto il GPIO 26 per il relè per un motivo: i GPIO 0, 2, 12 e 15 sono pin di avvio (strapping) e influenzano il modo in cui parte la scheda; i GPIO 1 e 3 sono riservati alla porta seriale, i 6–11 alla memoria flash interna e i GPIO 5 e 14 generano brevi segnali all'avvio. Il GPIO 26 non fa nulla di tutto questo. Il GPIO 2, invece, va benissimo come semplice uscita che pilota il LED della scheda. È importante anche usare il contatto NO (normalmente aperto) del relè: quando l'ESP32 è spento, si resetta o si guasta, il relè si diseccita e la presa resta senza tensione. Con il contatto NC accade l'opposto e, in caso di guasto, il dispositivo resterebbe sempre acceso.
Prova prima a bassa tensione
- Alimenta l'ESP32 solo via cavo USB; in questa fase non collegare affatto l'HLK-PM01. Collega VCC del modulo relè al pin 5V (VIN) dell'ESP32, GND a GND e IN al GPIO 26.
- Ai contatti COM e NO del relè collega, al posto dei 230 V, un carico a bassa tensione: bastano un alimentatore da 12 V con una breve striscia LED, oppure un LED alimentato a 5 V con una resistenza da 220 Ω.
- Carica il codice di test qui sotto e apri il Serial Monitor a 115200 baud: il relè deve scattare ogni 2 secondi e il LED deve lampeggiare.
- Se il relè funziona al contrario (il carico si spegne mentre sullo schermo c'è scritto "ACIK"), cambia il valore di RELAY_ACTIVE_LOW nel codice.
- Poi carica il codice con pannello web, prova accensione/spegnimento e timer dal telefono; resetta l'ESP32 e verifica che il relè parta spento e che la scheda non si blocchi quando il Wi-Fi cade.
- Lascia funzionare il montaggio per un giorno intero a bassa tensione e controlla che il programma NTP accenda e spenga all'ora giusta; solo dopo passa all'installazione di rete.
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}La funzione relaySet() traduce i comandi "accendi" e "spegni" nella logica di attivazione del modulo. La maggior parte dei moduli relè in commercio è attiva a livello BASSO: il relè scatta quando il pin IN viene portato a GND. Gestire questa logica invertita con una sola costante (RELAY_ACTIVE_LOW), invece di pensarci in ogni punto del codice, evita errori. C'è anche un vantaggio: quando l'ESP32 si avvia o si resetta, i pin sono in ingresso e un modulo attivo BASSO con il pin IN lasciato libero non scatta da solo in quel momento. Per la struttura interna e il circuito di pilotaggio del relè dai un'occhiata a Che cos'è un modulo relè?.
Codice della presa intelligente con pannello web
Se il test è andato bene, puoi passare al codice vero e proprio. La libreria WebServer inclusa nel core Arduino per ESP32 non richiede installazioni aggiuntive e funziona allo stesso modo nelle versioni 2.x e 3.x del core. Il codice offre un pannello di controllo nella pagina principale, i comandi agli indirizzi /on, /off, /toggle e /timer?min=30 e lo stato della presa in formato JSON su /state. Il pannello interroga /state ogni 2 secondi, così vedi sul telefono anche le modifiche fatte con il pulsante sulla scatola o dal programma. Non dimenticare di cambiare in cima al codice nome e password del Wi-Fi con quelli della tua rete; l'ESP32 si collega solo a reti a 2,4 GHz. Per aggiornamenti in tempo reale guarda l'articolo Server web ESP32 e 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}| Parte di codice | Che cosa fa |
|---|---|
| relaySet(bool on) | Aggiorna insieme relè, LED di stato e variabile relayOn |
| server.on("/timer", ...) | Con un parametro come ?min=30 accende la presa e la spegne allo scadere del tempo (1–720 minuti) |
| minutesLeft() | Calcola il tempo residuo del timer in minuti, arrotondando per eccesso |
| (long)(millis() - offAtMs) >= 0 | Confronto dei tempi che resiste all'overflow di millis() (circa 49,7 giorni) |
| configTzTime("<+03>-3", ...) | Ottiene l'ora dai server NTP e la converte nell'ora turca (UTC+3) |
| lastCheckedMinute | Fa sì che il programma venga controllato una sola volta al minuto; non sovrascrive un comando dato a mano |
| MDNS.begin("akillipriz") | Ti permette di raggiungere il pannello con http://akillipriz.local invece dell'IP |
Funzionamento automatico con timer e NTP
L'ESP32 non ha un orologio con batteria: quando si accende non conosce l'ora del giorno. La chiamata a configTzTime() avvia in background il client SNTP, ottiene l'ora UTC da server come pool.ntp.org e la converte in ora locale in base alla stringa del fuso orario che indichi. Una volta ottenuta l'ora, l'ESP32 continua a contare con il proprio timer e per impostazione predefinita si risincronizza ogni ora. Poiché la Turchia non adotta l'ora legale dal 2016, basta la stringa "<+03>-3"; nel formato POSIX il segno è invertito, quindi UTC+3 compare come -3. Per i dettagli guarda ESP32 e l'ora di Internet con NTP.
Nel codice ci sono due tipi di funzionamento automatico. Il primo è il timer a conto alla rovescia: il pulsante "30 min" del pannello accende la presa e la spegne allo scadere del tempo; è l'ideale per dispositivi che non vuoi dimenticare accesi, come caricabatterie, aeratore per acquario o ventilatore da stanza. Il secondo è il programma giornaliero: ogni giorno la presa si accende all'ora onMinute e si spegne all'ora offMinute. Poiché il programma interviene solo nel momento in cui cambia il minuto e proprio in quel minuto, una lampada che spegni a mano alle 20:00 resta spenta fino al successivo orario di accensione. Per lo stesso motivo funzionano senza problemi anche programmi che superano la mezzanotte, come accendere alle 22:00 e spegnere alle 06:00.
| Impostazione | Valore d'esempio | Risultato |
|---|---|---|
| onMinute | 18 * 60 + 30 | Accende ogni giorno alle 18:30 |
| offMinute | 23 * 60 | Spegne ogni giorno alle 23:00 |
| onMinute e offMinute | 7 * 60 e 21 * 60 | La lampada per acquario o piante resta accesa dalle 07:00 alle 21:00 |
| scheduleEnabled | false | Programma giornaliero disattivato; funzionano solo pannello, pulsante e conto alla rovescia |
| Fuso orario di configTzTime | "CET-1CEST,M3.5.0,M10.5.0/3" | Ora dell'Europa centrale, con i passaggi all'ora legale |
Limite di carico: che cosa puoi collegare alla presa?
La corrente assorbita da un dispositivo si ricava con la formula I = P / V: a 230 V un apparecchio da 1000 W assorbe 1000 / 230 ≈ 4,3 A. Il fatto che sul relè ci sia scritto "10A 250VAC" non significa che il modulo possa portare 10 A in modo continuo; le piste del circuito stampato, i morsetti a vite e lo stesso relè dei moduli economici si scaldano a quella corrente. Inoltre i dispositivi con motore o compressore assorbono all'avvio diverse volte la corrente di regime e i contatti fanno un arco a ogni commutazione. Come limite pratico sicuro, tieni il carico continuo sotto 2–3 A (circa 500–700 W). I dettagli del calcolo della potenza sono nell'articolo Calcolo della potenza elettrica.
| Dispositivo | Potenza tipica | Corrente (230 V) | Per questa presa |
|---|---|---|---|
| Lampadina LED | 9–12 W | 0,04–0,05 A | Adatto |
| Router / modem | 10–15 W | 0,04–0,07 A | Adatto (ideale per il riavvio da remoto) |
| Caricabatterie di telefono e laptop | 20–65 W | 0,09–0,28 A | Adatto |
| Ventilatore da tavolo | 40–60 W | 0,17–0,26 A | Adatto (carico induttivo, i contatti si consumano più in fretta) |
| Riscaldatore per acquario | 100–200 W | 0,43–0,87 A | Adatto |
| Macchina del caffè | 1000–1500 W | 4,3–6,5 A | Sconsigliato |
| Bollitore, ferro da stiro, stufetta elettrica | 2000–2400 W | 8,7–10,4 A | Assolutamente no |
Scatola e sicurezza di rete
- Si interrompe la fase, non il neutro: il relè va sempre sulla linea di fase (L). Se interrompi il neutro, anche a presa spenta dentro l'apparecchio c'è la fase e il pericolo di contatto resta.
- Terra senza interruzioni: il contatto di terra della presa con messa a terra va collegato direttamente al conduttore di terra in ingresso; non passa dal relè né dalla scheda.
- Separa gli scomparti: i cavi a 230 V, i contatti del relè e l'ingresso dell'HLK-PM01 stiano da un lato della scatola; l'ESP32 e i cavi a 5 V dall'altro. Lascia almeno 6 mm di distanza tra le due zone e, se serve, metti un divisorio di plastica.
- Cavi e morsetti adeguati: sul lato rete usa cavo multifilare da almeno 1,5 mm², con puntalini ai capi e morsetti robusti. Cavi jumper e breadboard non devono mai stare sul lato rete.
- Fusibile: sulla linea del carico metti un fusibile inferiore al limite del relè (ad esempio 5 A) e, sull'ingresso dell'HLK-PM01, un altro fusibile separato di valore piccolo.
- Scatola: scegli una scatola di plastica autoestinguente (UL94 V-0); se usi una scatola metallica, collegala a terra. Fissa il cavo d'ingresso con un passacavo o una fascetta, così che se viene tirato non si stacchi dai morsetti.
- Aggiornamento del programma: non collegare il cavo USB e non aprire il coperchio mentre la scatola è collegata alla rete. Per caricare il codice senza fili puoi aggiungere il metodo aggiornamento OTA dell'ESP32.
- Prima alimentazione: prima di collegare alla rete per la prima volta, controlla con il multimetro che non ci siano corto circuiti tra i cavi; fai la prima prova su una linea protetta da interruttore differenziale e con una piccola lampadina LED.
Idee di progetto e miglioramenti
- Collegala alla domotica: aggiungi la presa agli altri dispositivi smart e agli scenari di automazione con MQTT e Home Assistant.
- Controllo da fuori casa: aggiungendo un bot Telegram accendi e spegni la presa da ovunque senza aprire porte sul router.
- Togli la password dal codice: con WiFiManager inserisci i dati Wi-Fi dal telefono al primo avvio; se la rete cambia non devi ricaricare il codice.
- Presa con termostato: aggiungi un DHT11 o un DS18B20 e fai funzionare il riscaldatore o la ventola in base alla temperatura.
- Commutazione silenziosa: se non vuoi il clic e l'usura dei contatti, con carichi resistivi usa un relè a stato solido (SSR).
- Presa a movimento: con un sensore PIR costruisci un sistema che accende la lampada quando entri nella stanza e la spegne dopo 5 minuti senza movimento.
- Versione Pico W: se vuoi provare la stessa idea con MicroPython, parti dall'articolo sul server web con Pico W.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il relè non si diseccita mai | Modulo attivo BASSO alimentato a 5 V: l'HIGH a 3,3 V non lo chiude del tutto | Separa JD-VCC oppure usa un modulo attivato a 3,3 V |
| Quando il relè scatta l'ESP32 si resetta | Calo di tensione (brownout) o disturbi causati dall'arco dei contatti | Aggiungi condensatori da 470 µF e 100 nF sulla linea 5V, accorcia i cavi |
| Il pannello non si apre | Il telefono è su un'altra rete, l'IP è cambiato o l'ESP32 non si è connesso al Wi-Fi | Controlla l'IP nel Serial Monitor, assegna un IP fisso |
| L'ora risulta "--:--" | Server NTP non raggiungibile | Controlla la connessione a Internet e il DNS, aggiungi un secondo server |
| Il programma parte con 3 ore di scarto | Fuso orario non indicato, viene usato UTC | Scrivi la stringa del fuso orario corretta con configTzTime |
| All'avvio il relè scatta per un attimo | È stato scelto un pin di avvio come GPIO 0, 2, 12, 15 oppure il modulo è attivo ALTO | Usa un pin sicuro come il GPIO 26, controlla il tipo di modulo |
| Relè e morsetti si scaldano | Il carico è troppo grande per il modulo | Riduci il carico sotto 2–3 A, per carichi grandi usa un contattore |
La presa intelligente ESP32 è un esercizio molto istruttivo perché riunisce in un solo progetto Wi-Fi, server web, gestione del tempo ed elettronica di potenza. Se procedi con ordine e pazienza ottieni un dispositivo simile ai prodotti commerciali, ma controllato interamente da te. Nell'app BlueGrays puoi migliorarla ancora, studiando passo dopo passo con schemi e codici pronti i progetti su server web ESP32, orologio NTP, mDNS e illuminazione a relè.
Domande frequenti
È sicuro costruire una presa intelligente con ESP32?
Il lato a bassa tensione (ESP32, bobina del relè e codice) è del tutto sicuro; il vero rischio sta sul lato 230 V. Le regole di base sono interrompere la fase con il relè, lasciare la terra senza interruzioni, usare un fusibile e mettere tutto in una scatola chiusa autoestinguente. Se non hai esperienza, prova prima con un carico a 12 V e fai controllare il collegamento alla rete da chi se ne intende.
L'HLK-PM01 alimenta insieme ESP32 e relè?
Sì, per un circuito con un solo relè basta. L'HLK-PM01 fornisce 600 mA a 5 V; l'ESP32 assorbe in media 80–120 mA, circa 300 mA nei picchi Wi-Fi, e la bobina del relè 70–90 mA. Per smorzare le oscillazioni di tensione aggiungi un condensatore da 470 µF sulla linea 5 V; se userai più relè scegli un modulo da 5 W come l'HLK-5M05.
L'ESP32 può pilotare un modulo relè a 5 V?
La maggior parte dei moduli con pilota a transistor si attiva senza problemi con l'uscita a 3,3 V dell'ESP32: la bobina è alimentata a 5 V e dal pin dell'ESP32 passano solo pochi milliampere. Nei moduli con optoaccoppiatore e attivi a livello BASSO, invece, il livello HIGH a 3,3 V può non diseccitare del tutto il relè. In tal caso togli il jumper JD-VCC, collega VCC a 3V3 e JD-VCC ai 5 V.
Che cosa fa la presa intelligente quando manca e torna la corrente?
Per sicurezza il codice di questo articolo fa partire il relè spento a ogni avvio. Se vuoi che ricordi l'ultimo stato, puoi salvarlo nella memoria flash con la libreria Preferences e ripristinarlo in setup(). L'ora NTP viene riacquisita in pochi secondi appena torna la connessione a Internet e il programma giornaliero riprende da dove era rimasto.
Posso controllare la presa intelligente da fuori casa via Internet?
Il pannello web di questo codice è raggiungibile solo dalla rete locale di casa. Per il controllo da remoto, invece di aprire porte sul router, è più facile e più sicuro usare un servizio come bot Telegram, MQTT, Blynk o Firebase. Poiché è l'ESP32 a collegarsi a questi servizi, non apri alcun accesso dall'esterno alla rete di casa.
Quanti watt può avere un dispositivo collegato alla presa ESP32?
Anche se sui relè hobbistici c'è scritto 10 A, è sicuro tenere il carico continuo sotto 2–3 A, cioè circa 500–700 W a 230 V. Lampade, caricabatterie, router, ventilatori e attrezzatura per acquari vanno bene. Bollitori, ferri da stiro, stufette elettriche e condizionatori non vanno collegati a questo progetto.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
In questo progetto due pulsanti collegati all'ESP32 (GPIO 5 incrementa, GPIO 4 decrementa) modificano un contatore. Il valore si aggiorna all'istante su un display LCD I2C 16x2 e, grazie al supporto WebSocket di ESPAsyncWebServer, in tutti i browser collegati senza ricaricare la pagina. Al posto del polling HTTP si usa un'unica connessione persistente e l'ESP32 invia il nuovo valore a tutti con ws.textAll().

ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
Aggiungiamo all'ESP32 un servizio mDNS (Multicast DNS), così lo raggiungi con un nome host leggibile come bluegrays-esp.local invece che con un indirizzo IP. Anche se l'IP assegnato dal DHCP cambia, il dispositivo risponde sempre allo stesso nome. Un piccolo server web sulla scheda ti permette di controllare il LED dal browser all'indirizzo http://bluegrays-esp.local/.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

Accendere una lampadina 220V con il telecomando
Accendi e spegni una vera lampadina di casa con un telecomando, senza alzarti dal divano.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

