Guide · 8 min di lettura

Timer luci di Natale con ESP32: accensione automatica al tramonto

Timer luci di Natale con ESP32: ora NTP e posizione danno il tramonto, un relè accende le luci e le spegne a mezzanotte. Tabella delle città e controllo web.

Il grande vantaggio di usare un ESP32 come timer per le luci di Natale è che accende le luci quando il sole tramonta davvero nel posto in cui vivi, e non a un orario fisso. L'ESP32 si collega al Wi-Fi, prende l'ora da internet tramite NTP, calcola alba e tramonto del giorno dalla latitudine e dalla longitudine che inserisci, accende la catena luminosa con un modulo relè e la spegne da solo a mezzanotte. In più, con una piccola pagina web sul telefono puoi accendere e spegnere le luci anche a mano, e la modalità scelta resta memorizzata persino dopo un blackout.

In questa guida mostriamo prima perché il tramonto si sposta ogni giorno e quanto cambia da una città all'altra, poi spieghiamo passo passo la formula del calcolo. Seguono due sketch: il primo scrive soltanto alba e tramonto di oggi nel Monitor seriale, il secondo è un timer completo con relè, spegnimento a mezzanotte e controllo web. L'ultima parte riguarda la sicurezza all'aperto e gli errori più comuni. Se vuoi ripassare le basi dell'NTP, dai un'occhiata a orologio NTP con ESP32.

Modulo relè per un timer delle luci di Natale con ESP32
Modulo relè: l'interruttore che apre e chiude l'alimentazione della catena luminosa con il segnale a 3,3 V dell'ESP32.

Perché il tramonto e non un orario fisso?

Un timer da presa meccanico o digitale accende ogni sera alla stessa ora, ma il tramonto si sposta per tutta la stagione. A Roma il sole tramonta alle 17:05 il 1° novembre, alle 16:40 il 1° dicembre e alle 17:21 il 31 gennaio, con una variazione di oltre 40 minuti nel periodo natalizio. Un orario fisso alle 16:45 accende le luci in pieno giorno a inizio novembre e a fine gennaio; se lo sposti alle 17:00, a metà dicembre si accendono circa venti minuti dopo il buio. Anche il luogo conta molto: il 21 dicembre il sole tramonta alle 15:53 a Berlino e alle 17:51 a Madrid, anche se le due città hanno lo stesso fuso orario. La tabella riporta i tramonti calcolati con la stessa formula del codice; di solito differiscono dai valori ufficiali di uno o due minuti.

CittàLatitudine, longitudine1 dic10 dic21 dic31 dic
Istanbul41,01 / 28,9817:3717:3617:3817:44
Ankara39,93 / 32,8617:2517:2317:2617:32
Smirne38,42 / 27,1417:5117:5117:5317:59
Londra51,51 / -0,1315:5615:5215:5315:59
Berlino52,52 / 13,4115:5715:5315:5316:00
Monaco di Baviera48,14 / 11,5816:2316:2016:2216:28
Vienna48,21 / 16,3716:0416:0116:0216:08
Madrid40,42 / -3,7017:4917:4817:5117:57
Parigi48,86 / 2,3516:5716:5416:5517:02
Roma41,90 / 12,5016:4016:3916:4116:47
Milano45,46 / 9,1916:4216:4016:4216:48
New York40,71 / -74,0116:3016:2816:3116:37
Città del Messico19,43 / -99,1317:5717:5918:0318:08

La tabella nasconde un dettaglio curioso: anche se il 21 dicembre è il giorno più corto, il tramonto più anticipato arriva una decina di giorni prima, nella prima metà di dicembre. Il motivo è l'equazione del tempo: l'orbita terrestre non è un cerchio perfetto e l'asse è inclinato, così a dicembre il sole raggiunge il punto più alto in cielo circa 30 secondi più tardi ogni giorno. Il tramonto viene spinto in avanti con lo stesso ritardo, mentre al mattino il sole continua a sorgere sempre più tardi fino all'inizio di gennaio. Un timer a orario fisso non può mai seguire questa finezza; la formula ne tiene conto da sola.

Come si calcola il tramonto?

Il codice usa le formule solari approssimate pubblicate dall'agenzia statunitense per gli oceani e l'atmosfera (NOAA). Il calcolo richiede solo il giorno dell'anno, la latitudine e la longitudine; non scarica altri dati da internet. Il risultato è in minuti UTC, che il codice converte in ora locale con l'impostazione del fuso orario, quindi funziona correttamente anche nei paesi con l'ora legale. Sotto i 60° di latitudine la formula è precisa entro uno o due minuti; nelle regioni polari, quando il sole non tramonta o non sorge per tutto il giorno, l'arcocoseno non è definito e il codice lo controlla a parte.

PassoFormulaSpiegazione
1. Frazione dell'annoγ = 2π / 365 × (giorno − 1)Converte il giorno dell'anno in radianti
2. Equazione del tempoeqtime = 229,18 × (0,000075 + 0,001868 cos γ − 0,032077 sin γ − 0,014615 cos 2γ − 0,040849 sin 2γ)Differenza tra ora solare e ora dell'orologio, circa da −14 a +16 min nell'anno
3. Declinazione solareδ = 0,006918 − 0,399912 cos γ + 0,070257 sin γ − ...Circa −23,44° intorno al 21 dicembre
4. Angolo orarioha = arccos(cos 90,833° / (cos φ cos δ) − tan φ tan δ)90,833°: rifrazione all'orizzonte (0,567°) + raggio del sole (0,267°)
5. Tramonto720 − 4 × (longitudine − ha) − eqtimeMinuti UTC; ogni grado di longitudine vale 4 minuti

Materiale

  • Scheda di sviluppo ESP32 (da 30 o 38 pin, è indifferente)
  • Modulo relè a 1 canale: con optoisolatore e contatti da 10 A 250 V AC; oppure un relè a stato solido (SSR) silenzioso
  • Alimentatore USB 5 V 1–2 A e cavo USB per l'ESP32
  • Catena luminosa: meglio una catena LED da esterno a bassa tensione (5–31 V) con il suo alimentatore
  • Scatola di derivazione IP65, pressacavi e morsetti
  • Qualche cavetto jumper

Collegamenti: ESP32 e modulo relè

Modulo relèESP32Nota
VCCVIN (5 V)La bobina del relè richiede 5 V; basta il pin VIN alimentato via USB
GNDGNDMassa comune
INGPIO 26RELAY_PIN nel codice; la maggior parte dei moduli si attiva con LOW
COMUscita + dell'alimentatore della catenaIngresso della linea commutata
NO (normalmente aperto)Ingresso + della catenaIl circuito si chiude quando il relè si eccita
NC (normalmente chiuso)LiberoNon usato
C'è una trappola frequente con i moduli relè a 5 V con optoisolatore che si attivano con LOW: poiché il livello HIGH dell'ESP32 è di 3,3 V, il LED dell'optoisolatore può non spegnersi del tutto e il relè non si rilascia mai. Se succede, togli il ponticello JD-VCC e porta 5 V a JD-VCC e 3,3 V a VCC, oppure usa un modulo con comando a 3,3 V o un transistor NPN. Inoltre non collegare IN ai pin di avvio come GPIO 0, 2, 12 e 15: all'accensione dell'ESP32 cambiano stato per un attimo e le luci lampeggiano.

Passo 1: vedere il tramonto di oggi nel Monitor seriale

  1. Nell'Arduino IDE installa il pacchetto esp32 dal Gestore schede e scegli ESP32 Dev Module come scheda.
  2. Nel codice qui sotto scrivi nome e password della tua rete in WIFI_SSID e WIFI_PASS.
  3. Modifica LATITUDE e LONGITUDE per la tua città; le longitudini ovest e le latitudini sud sono negative.
  4. Fuori dalla Turchia scegli la riga TZ_INFO dalla tabella dei fusi orari più sotto; per l'Italia è "CET-1CEST,M3.5.0,M10.5.0/3".
  5. Carica il codice, apri il Monitor seriale a 115200 baud e confronta gli orari con la tabella.
C++ (Arduino IDE)
1// ESP32: NTP saati + bugünün gün doğumu/batımı (Seri Monitör)
2// ESP32: NTP time + today's sunrise/sunset (Serial Monitor)
3#include <WiFi.h>
4#include <time.h>
5#include <math.h>
6
7const char* WIFI_SSID = "AgAdi";          // Wi-Fi adı / Wi-Fi name
8const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifresi / Wi-Fi password
9const char* TZ_INFO   = "<+03>-3";        // Türkiye UTC+3 / Turkey UTC+3
10const double LATITUDE  = 41.01;           // İstanbul enlemi (kuzey +) / latitude (north +)
11const double LONGITUDE = 28.98;           // İstanbul boylamı (doğu +) / longitude (east +)
12
13// NOAA yaklaşık formülü, sonuç UTC dakika / NOAA approximation, result in UTC minutes
14bool sunTimesUtc(int yday, int year, double &riseUtc, double &setUtc) {
15  int daysInYear = ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? 366 : 365;
16  double g = 2.0 * PI / daysInYear * yday;                    // yılın kesri (radyan) / fractional year (rad)
17  double eqTime = 229.18 * (0.000075 + 0.001868 * cos(g) - 0.032077 * sin(g)
18                  - 0.014615 * cos(2 * g) - 0.040849 * sin(2 * g));            // zaman denklemi (dk) / equation of time (min)
19  double decl = 0.006918 - 0.399912 * cos(g) + 0.070257 * sin(g) - 0.006758 * cos(2 * g)
20              + 0.000907 * sin(2 * g) - 0.002697 * cos(3 * g) + 0.00148 * sin(3 * g);  // eğim (rad) / declination (rad)
21  double lat = LATITUDE * DEG_TO_RAD;
22  double x = cos(90.833 * DEG_TO_RAD) / (cos(lat) * cos(decl)) - tan(lat) * tan(decl);
23  if (x < -1.0 || x > 1.0) return false;                      // kutup gecesi ya da gündüzü / polar night or day
24  double ha = acos(x) * RAD_TO_DEG;                           // saat açısı (derece) / hour angle (degrees)
25  riseUtc = 720 - 4 * (LONGITUDE + ha) - eqTime;
26  setUtc  = 720 - 4 * (LONGITUDE - ha) - eqTime;
27  return true;
28}
29
30void setup() {
31  Serial.begin(115200);
32  WiFi.begin(WIFI_SSID, WIFI_PASS);
33  while (WiFi.status() != WL_CONNECTED) {
34    delay(500);
35    Serial.print(".");
36  }
37  configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
38  struct tm now;
39  while (!getLocalTime(&now)) {
40    Serial.println("NTP bekleniyor / waiting for NTP");
41  }
42
43  struct tm noon = now;                     // yerel öğle: günün UTC tarihini bulmak için / local noon to find today's UTC date
44  noon.tm_hour = 12; noon.tm_min = 0; noon.tm_sec = 0; noon.tm_isdst = -1;
45  time_t noonT = mktime(&noon);
46  time_t utcMidnight = noonT - (noonT % 86400);
47
48  double riseUtc, setUtc;
49  if (sunTimesUtc(now.tm_yday, now.tm_year + 1900, riseUtc, setUtc)) {
50    time_t riseT = utcMidnight + (time_t)(riseUtc * 60);
51    time_t setT  = utcMidnight + (time_t)(setUtc * 60);
52    struct tm r, s;
53    localtime_r(&riseT, &r);
54    localtime_r(&setT, &s);
55    Serial.printf("Bugun / today: %02d.%02d.%d\n", now.tm_mday, now.tm_mon + 1, now.tm_year + 1900);
56    Serial.printf("Gun dogumu / sunrise: %02d:%02d\n", r.tm_hour, r.tm_min);
57    Serial.printf("Gun batimi / sunset:  %02d:%02d\n", s.tm_hour, s.tm_min);
58  }
59}
60
61void loop() {
62}

La parte più delicata del codice è la conversione tra UTC e ora locale. La formula restituisce il tramonto come minuti dopo la mezzanotte UTC del giorno. Il codice trasforma prima il mezzogiorno locale di oggi in un timestamp con mktime(), poi sottrae il resto della divisione per 86400 per ottenere la mezzanotte UTC della stessa data. A questo valore si sommano i minuti del tramonto e localtime_r() converte il risultato nel tuo fuso orario. Partire dal mezzogiorno evita di calcolare il giorno sbagliato nelle ore notturne in cui la data UTC e quella locale non coincidono.

Passo 2: il codice completo con relè, spegnimento a mezzanotte e controllo web

Il secondo sketch trasforma il calcolo del tramonto in un timer. Ogni 10 secondi controlla l'ora; se il giorno è cambiato ricalcola alba e tramonto e, in modalità automatica, decide se le luci devono essere accese. La libreria integrata WebServer offre una piccola pagina sulla porta 80: aprendo l'IP dell'ESP32 nel browser vedi lo stato delle luci, alba e tramonto di oggi e i link AUTO, ON e OFF. La modalità scelta viene salvata nella flash con Preferences, così dopo un blackout il timer riparte nella stessa modalità.

C++ (Arduino IDE)
1// ESP32 Noel ışıkları zamanlayıcısı: gün batımında aç, gece yarısı kapat, web'den elle kontrol
2// ESP32 Christmas lights timer: on at sunset, off at midnight, manual control from the web
3#include <WiFi.h>
4#include <WebServer.h>
5#include <Preferences.h>
6#include <time.h>
7#include <math.h>
8
9const char* WIFI_SSID = "AgAdi";          // Wi-Fi adı / Wi-Fi name
10const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifresi / Wi-Fi password
11const char* TZ_INFO   = "<+03>-3";        // Türkiye / Turkey. Berlin, Paris, Roma, Madrid: "CET-1CEST,M3.5.0,M10.5.0/3"
12const double LATITUDE  = 41.01;           // enlem (kuzey +) / latitude (north +)
13const double LONGITUDE = 28.98;           // boylam (doğu +, batı -) / longitude (east +, west -)
14
15const int  RELAY_PIN = 26;                // röle modülü IN / relay module IN
16const bool RELAY_ACTIVE_LOW = true;       // çoğu modül LOW ile çeker / most modules switch on LOW
17const int  SUNSET_OFFSET_MIN = 0;         // gün batımına göre kayma (dk), -15 = 15 dk önce / shift from sunset (min)
18const int  OFF_MINUTE = 24 * 60;          // kapanış: 24:00 = gece yarısı, 23:30 için 23*60+30 / off time
19const int  MORNING_ON_MINUTE = -1;        // sabah açılış, ör. 6*60+30; -1 = kapalı / morning on, e.g. 6:30; -1 = off
20
21enum Mode : uint8_t { MODE_AUTO, MODE_ON, MODE_OFF };
22Mode mode = MODE_AUTO;
23bool lightsOn = false;
24int sunriseMin = -1, sunsetMin = -1;      // bugünün yerel dakikası / today's local minute of day
25int lastYday = -1;
26unsigned long lastCheck = 0;
27
28WebServer server(80);
29Preferences prefs;
30
31bool sunTimesUtc(int yday, int year, double &riseUtc, double &setUtc) {
32  int daysInYear = ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? 366 : 365;
33  double g = 2.0 * PI / daysInYear * yday;
34  double eqTime = 229.18 * (0.000075 + 0.001868 * cos(g) - 0.032077 * sin(g)
35                  - 0.014615 * cos(2 * g) - 0.040849 * sin(2 * g));
36  double decl = 0.006918 - 0.399912 * cos(g) + 0.070257 * sin(g) - 0.006758 * cos(2 * g)
37              + 0.000907 * sin(2 * g) - 0.002697 * cos(3 * g) + 0.00148 * sin(3 * g);
38  double lat = LATITUDE * DEG_TO_RAD;
39  double x = cos(90.833 * DEG_TO_RAD) / (cos(lat) * cos(decl)) - tan(lat) * tan(decl);
40  if (x < -1.0 || x > 1.0) return false;
41  double ha = acos(x) * RAD_TO_DEG;
42  riseUtc = 720 - 4 * (LONGITUDE + ha) - eqTime;
43  setUtc  = 720 - 4 * (LONGITUDE - ha) - eqTime;
44  return true;
45}
46
47int toLocalMinute(time_t utcMidnight, double utcMinutes) {
48  time_t t = utcMidnight + (time_t)(utcMinutes * 60);
49  struct tm lt;
50  localtime_r(&t, &lt);
51  return lt.tm_hour * 60 + lt.tm_min;
52}
53
54void updateSunTimes(struct tm now) {      // günde bir kez / once a day
55  now.tm_hour = 12; now.tm_min = 0; now.tm_sec = 0; now.tm_isdst = -1;
56  time_t noonT = mktime(&now);
57  time_t utcMidnight = noonT - (noonT % 86400);
58  double r, s;
59  if (sunTimesUtc(now.tm_yday, now.tm_year + 1900, r, s)) {
60    sunriseMin = toLocalMinute(utcMidnight, r);
61    sunsetMin  = toLocalMinute(utcMidnight, s);
62  }
63  lastYday = now.tm_yday;
64  Serial.printf("Gun dogumu %02d:%02d, gun batimi %02d:%02d\n", sunriseMin / 60, sunriseMin % 60, sunsetMin / 60, sunsetMin % 60);
65}
66
67void setRelay(bool on) {
68  lightsOn = on;
69  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
70}
71
72bool autoWantsOn(int nowMin) {
73  if (sunsetMin < 0) return false;
74  if (nowMin >= sunsetMin + SUNSET_OFFSET_MIN && nowMin < OFF_MINUTE) return true;   // akşam / evening
75  if (MORNING_ON_MINUTE >= 0 && nowMin >= MORNING_ON_MINUTE && nowMin < sunriseMin) return true;  // sabah / morning
76  return false;
77}
78
79void applyState() {
80  struct tm now;
81  if (!getLocalTime(&now, 10)) {          // saat henüz yok / no time yet
82    setRelay(mode == MODE_ON);
83    return;
84  }
85  if (now.tm_yday != lastYday) updateSunTimes(now);
86  int nowMin = now.tm_hour * 60 + now.tm_min;
87  bool on = (mode == MODE_ON) || (mode == MODE_AUTO && autoWantsOn(nowMin));
88  if (on != lightsOn) {
89    setRelay(on);
90    Serial.printf("%02d:%02d isiklar %s\n", now.tm_hour, now.tm_min, on ? "ACIK / on" : "KAPALI / off");
91  }
92}
93
94String hhmm(int m) {
95  if (m < 0) return "--:--";
96  char buf[12];
97  snprintf(buf, sizeof(buf), "%02d:%02d", m / 60, m % 60);
98  return String(buf);
99}
100
101void handleRoot() {
102  String html = F("<!DOCTYPE html><html><head><meta charset='utf-8'>"
103                  "<meta name='viewport' content='width=device-width,initial-scale=1'>"
104                  "<title>Noel</title></head><body style='font-family:sans-serif;text-align:center'>");
105  html += "<h2>" + String(lightsOn ? "ON" : "OFF") + "</h2>";
106  html += "<p>Sunrise " + hhmm(sunriseMin) + " | Sunset " + hhmm(sunsetMin) + "</p>";
107  html += "<p>Mode: " + String(mode == MODE_AUTO ? "AUTO" : (mode == MODE_ON ? "ON" : "OFF")) + "</p>";
108  html += F("<p><a href='/mode?m=auto'>AUTO</a> | <a href='/mode?m=on'>ON</a> | <a href='/mode?m=off'>OFF</a></p></body></html>");
109  server.send(200, "text/html", html);
110}
111
112void handleMode() {
113  String m = server.arg("m");
114  mode = (m == "on") ? MODE_ON : (m == "off") ? MODE_OFF : MODE_AUTO;
115  prefs.putUChar("mode", mode);           // elektrik kesilse de hatırla / remember after a power cut
116  applyState();
117  server.sendHeader("Location", "/");
118  server.send(303);
119}
120
121void setup() {
122  digitalWrite(RELAY_PIN, RELAY_ACTIVE_LOW ? HIGH : LOW);   // açılışta kapalı başla / start switched off
123  pinMode(RELAY_PIN, OUTPUT);
124  Serial.begin(115200);
125
126  prefs.begin("noel", false);
127  mode = (Mode)prefs.getUChar("mode", MODE_AUTO);
128
129  WiFi.mode(WIFI_STA);
130  WiFi.begin(WIFI_SSID, WIFI_PASS);
131  unsigned long start = millis();
132  while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) delay(500);
133  Serial.print("IP: ");
134  Serial.println(WiFi.localIP());
135
136  configTzTime(TZ_INFO, "pool.ntp.org", "time.cloudflare.com");
137  server.on("/", handleRoot);
138  server.on("/mode", handleMode);
139  server.begin();
140}
141
142void loop() {
143  server.handleClient();
144  if (millis() - lastCheck > 10000) {     // 10 sn'de bir kontrol / check every 10 s
145    lastCheck = millis();
146    applyState();
147  }
148}

Impostazioni

ImpostazionePredefinitoA cosa serve?
TZ_INFO"<+03>-3"Fuso orario e regola dell'ora legale (formato POSIX)
LATITUDE / LONGITUDE41.01 / 28.98Posizione; longitudine ovest e latitudine sud negative
RELAY_PIN26Pin collegato a IN del modulo relè
RELAY_ACTIVE_LOWtruetrue se il modulo si attiva con LOW, false se con HIGH
SUNSET_OFFSET_MIN0Spostamento rispetto al tramonto; −15 accende 15 min prima
OFF_MINUTE24 * 60Ora di spegnimento; per le 23:30 usa 23 * 60 + 30
MORNING_ON_MINUTE-1Accensione mattutina; con 6 * 60 + 30 le luci restano accese dalle 06:30 all'alba

Come funziona il codice?

La decisione viene presa in applyState(). Finché l'ora non è disponibile, le luci si accendono solo in modalità ON; così non si accendono all'orario sbagliato prima che arrivi il Wi-Fi. Con l'ora valida si calcola il minuto del giorno e si controllano due condizioni: la finestra serale va dal tramonto all'ora di spegnimento, quella mattutina opzionale dall'ora di accensione all'alba. Il relè commuta solo quando lo stato cambia e ogni cambiamento viene scritto nel Monitor seriale, il che semplifica la ricerca dei guasti. setRelay() scrive sul pin il livello corretto in base a RELAY_ACTIVE_LOW. In setup() il pin viene portato al livello di spento prima di essere impostato come uscita; quest'ordine evita che il relè scatti per un attimo all'avvio. Se il Wi-Fi cade, l'ESP32 continua con il suo orologio interno e l'NTP corregge di nuovo l'ora quando la connessione torna.

Se non vuoi leggere l'indirizzo IP nel Monitor seriale ogni volta, assegna all'ESP32 un IP fisso nel router (prenotazione DHCP) oppure raggiungilo per nome con mDNS. Se preferisci inserire i dati del Wi-Fi dal telefono invece di scriverli nel codice, puoi aggiungere a questo sketch il metodo di ESP32 WiFiManager.
RegioneTZ_INFO
Turchia<+03>-3
Germania, Austria, Italia, Francia, SpagnaCET-1CEST,M3.5.0,M10.5.0/3
Regno Unito, Irlanda, PortogalloGMT0BST,M3.5.0/1,M10.5.0
Costa est degli USA (New York)EST5EDT,M3.2.0,M11.1.0
Messico (Città del Messico)CST6

Sicurezza all'aperto

  • Preferisci la bassa tensione: con catene LED da 5–31 V dotate di alimentatore proprio, metti il relè sull'uscita a bassa tensione dell'alimentatore e non tocchi mai la tensione di rete.
  • Scatola e pressacavi: metti ESP32 e relè in una scatola IP65, fai passare i cavi nei pressacavi e monta la scatola con gli ingressi dei cavi rivolti verso il basso, così l'acqua non entra.
  • Calcolo della corrente: una tipica catena da 200 LED assorbe 10–20 W, meno di 0,1 A a 230 V. Non ti avvicinerai ai 10 A del relè, ma nei moduli economici il limite reale è più basso di quello stampato; tieni quindi il carico totale sotto pochi ampere.
  • Condensa: nelle notti d'inverno l'umidità può condensare dentro la scatola; aggiungi una bustina di gel di silice e fissa l'elettronica nella parte alta della scatola anziché sul fondo.
  • Niente carichi induttivi: usa questo timer solo per le luci; la corrente di spunto di motori, stufe o compressori può saldare in poco tempo i contatti del relè.
Se lavori con i 230 V, tutti i collegamenti devono stare in una scatola chiusa e isolata, il circuito va alimentato da una linea protetta da un interruttore differenziale (salvavita) da 30 mA e l'installazione va fatta a corrente staccata. Se non hai esperienza con gli impianti elettrici, usa il relè solo sul lato a bassa tensione oppure affida questa parte a un elettricista. Non lasciare accessibile nemmeno il modulo relè: le saldature dal lato dei contatti sono sotto tensione di rete.

Errori comuni e soluzioni

ProblemaCausaSoluzione
"In attesa dell'NTP" non finisce mai nel Monitor serialeWi-Fi non connesso o porta NTP bloccataControlla nome della rete e password, avvicina l'ESP32 al router
Il tramonto è sfasato di un'ora esattaTZ_INFO sbagliato o regola dell'ora legale mancanteUsa la stringa POSIX corretta dalla tabella
Il tramonto è sfasato di oreSegno della longitudine sbagliato o latitudine e longitudine invertiteInserisci la longitudine ovest in negativo e controlla l'ordine
Il relè non si rilascia maiIl modulo a 5 V non si spegne del tutto con un HIGH a 3,3 VSepara JD-VCC, usa un modulo a 3,3 V o un transistor
Le luci lampeggiano all'avvioPin di avvio o ordine di pinModeUsa un pin sicuro come GPIO 26, prima digitalWrite poi pinMode
La pagina web non si apreL'indirizzo IP è cambiatoImposta una prenotazione DHCP nel router o usa mDNS
Le luci restano accese dopo mezzanotteModalità rimasta su ONPassa ad AUTO dalla pagina web

Idee di progetti con questo timer

  • Sensore di luce di riserva: se il Wi-Fi resta assente a lungo, rileva il buio con una LDR e accendi comunque le luci.
  • Domotica: pubblica lo stato del relè via MQTT e controllalo da una dashboard di Home Assistant.
  • Programmazione multicanale: con una scheda a 4 relè assegna orari di spegnimento diversi alle luci del balcone, del giardino e della finestra.
  • Effetto tramonto: usa una striscia WS2812B al posto del relè e porta lentamente i colori fino a un bianco caldo al tramonto; il montaggio della striscia è in luci per l'albero di Natale.
  • Altri progetti di stagione: per idee che completano questo timer, sfoglia l'elenco dei progetti Arduino di Natale.

Se vuoi imparare i mattoni di questo timer uno alla volta, guarda nell'app BlueGrays i progetti sull'ora reale via NTP con ESP32, sul web server asincrono con ESP32 e sull'illuminazione intelligente con ESP32; ognuno include schema, elenco dei collegamenti e codice spiegato passo passo. Unisci questi mattoni al calcolo del tramonto di questo articolo e le tue luci di Natale si accenderanno da sole, puntuali, ogni sera.

Domande frequenti

Come si accendono automaticamente le luci di Natale al tramonto?

Il metodo più preciso è usare una scheda Wi-Fi come l'ESP32 per prendere l'ora via NTP e calcolare il tramonto del giorno da latitudine e longitudine. A quell'ora la scheda eccita un relè che accende le luci e le spegne all'orario scelto. Una soluzione più semplice è un crepuscolare con LDR, che però può essere ingannato da nuvole e lampioni.

L'ESP32 prende l'orario del tramonto da internet?

No, da internet prende solo l'ora tramite NTP. Il tramonto lo calcola da solo con le formule NOAA, per le quali bastano giorno dell'anno, latitudine e longitudine. Non servono quindi servizi meteo né chiavi API.

Il timer funziona anche se manca internet?

Sì. Una volta ottenuta l'ora, l'ESP32 continua a contare con il suo orologio interno e la deriva resta di solito entro pochi secondi al giorno. Quando la connessione torna, l'NTP corregge l'ora. Se però l'ESP32 si riavvia, la modalità automatica non accende le luci finché non riottiene l'ora.

Un modulo relè funziona con i 3,3 V dell'ESP32?

La maggior parte dei moduli relè a 5 V si attiva con un segnale a 3,3 V, ma alcuni moduli con optoisolatore attivi a LOW non si rilasciano del tutto con un HIGH a 3,3 V. In quel caso si risolve togliendo il ponticello JD-VCC e alimentando il modulo a parte, comprando un modulo con comando a 3,3 V oppure inserendo un transistor NPN.

Quale relè usare per le luci di Natale da esterno?

Per le luci basta un modulo relè meccanico con optoisolatore e contatti da 10 A 250 V AC; se il clic ti dà fastidio, usa un relè a stato solido (SSR). In ogni caso metti la scheda in una scatola stagna e alimenta il lato rete da una linea protetta da differenziale.

Si possono accendere le luci prima o dopo il tramonto?

Sì. SUNSET_OFFSET_MIN nel codice imposta lo spostamento in minuti: −15 accende le luci 15 minuti prima del tramonto, 20 le accende 20 minuti dopo. Poiché il crepuscolo dura circa 30 minuti, uno spostamento positivo di 10–20 minuti spesso dà l'effetto più bello.

Vedi tutti i progetti
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

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.

4.5(13)
22
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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).

4.8(16)
26
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

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.

4.3(6)
11
ESP32 Luce notturna con LDR
ES-10Principiante
Premium

ESP32 Luce notturna con LDR

Luce notturna in cui il LED si accende automaticamente al buio e si spegne alla luce. Viene utilizzato il pin D0 (digital out) del modulo sensore LDR - la soglia di buio viene impostata con il piccolo potenziometro sul modulo, il modulo stesso genera l'uscita HIGH/LOW. ESP32 legge questo segnale con digitalRead(), il codice è molto semplice.

4.6(17)
30
Controllo della striscia LED NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

Controllo della striscia LED NeoPixel WS2812B con ESP32

I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.

4.9(19)
30
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
ES-29Avanzato
Premium

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/.

4.8(14)
23
Lampadina 220V con pulsante (Push)
AR-19Avanzato
Premium

Lampadina 220V con pulsante (Push)

Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.

4.4(30)
38