Temporizador de luces de Navidad con ESP32: se encienden al ocaso
Temporizador de luces de Navidad con ESP32: la hora NTP y tu ubicación dan el ocaso, un relé enciende y apaga a medianoche. Tabla de ciudades y control web.
La gran ventaja de usar un ESP32 como temporizador de luces de Navidad es que enciende las luces cuando el sol se pone de verdad donde vives, y no a una hora fija. El ESP32 se conecta al Wi-Fi, obtiene la hora de internet mediante NTP, calcula la salida y la puesta de sol del día con la latitud y la longitud que le indiques, enciende la guirnalda con un módulo de relé y la apaga sola a medianoche. Además, con una pequeña página web en el móvil puedes encender y apagar las luces a mano, y el modo elegido se recuerda incluso después de un corte de luz.
En esta guía mostramos primero por qué la puesta de sol se desplaza cada día y cuánto cambia de una ciudad a otra, y después explicamos paso a paso la fórmula del cálculo. Luego vienen dos sketches: el primero solo escribe la salida y la puesta de sol de hoy en el Monitor Serie, y el segundo es un temporizador completo con relé, apagado a medianoche y control web. La última parte trata la seguridad en exteriores y los errores habituales. Si quieres repasar lo básico de NTP, echa un vistazo a reloj NTP con ESP32.

¿Por qué la puesta de sol y no una hora fija?
Un temporizador de enchufe mecánico o digital enciende cada tarde a la misma hora, pero la puesta de sol se mueve durante toda la temporada. En Madrid el sol se pone a las 18:13 el 1 de noviembre, a las 17:49 el 1 de diciembre y a las 18:29 el 31 de enero, una oscilación de unos 40 minutos en plena época navideña. Una hora fija de 17:45 enciende las luces con luz de día a principios de noviembre y a finales de enero; si la retrasas a las 18:15, a mediados de diciembre se encenderán casi media hora después de anochecer. La ubicación también influye mucho: el 21 de diciembre el sol se pone a las 15:53 en Berlín y a las 17:51 en Madrid, aunque las dos ciudades comparten huso horario. La tabla muestra las puestas de sol calculadas con la misma fórmula del código; suelen diferir de los valores oficiales en uno o dos minutos.
| Ciudad | Latitud, longitud | 1 dic | 10 dic | 21 dic | 31 dic |
|---|---|---|---|---|---|
| Estambul | 41,01 / 28,98 | 17:37 | 17:36 | 17:38 | 17:44 |
| Ankara | 39,93 / 32,86 | 17:25 | 17:23 | 17:26 | 17:32 |
| Esmirna | 38,42 / 27,14 | 17:51 | 17:51 | 17:53 | 17:59 |
| Londres | 51,51 / -0,13 | 15:56 | 15:52 | 15:53 | 15:59 |
| Berlín | 52,52 / 13,41 | 15:57 | 15:53 | 15:53 | 16:00 |
| Múnich | 48,14 / 11,58 | 16:23 | 16:20 | 16:22 | 16:28 |
| Viena | 48,21 / 16,37 | 16:04 | 16:01 | 16:02 | 16:08 |
| Madrid | 40,42 / -3,70 | 17:49 | 17:48 | 17:51 | 17:57 |
| París | 48,86 / 2,35 | 16:57 | 16:54 | 16:55 | 17:02 |
| Roma | 41,90 / 12,50 | 16:40 | 16:39 | 16:41 | 16:47 |
| Milán | 45,46 / 9,19 | 16:42 | 16:40 | 16:42 | 16:48 |
| Nueva York | 40,71 / -74,01 | 16:30 | 16:28 | 16:31 | 16:37 |
| Ciudad de México | 19,43 / -99,13 | 17:57 | 17:59 | 18:03 | 18:08 |
La tabla esconde un detalle curioso: aunque el 21 de diciembre es el día más corto, el atardecer más temprano llega unos diez días antes, en la primera quincena de diciembre. La razón es la ecuación del tiempo: la órbita de la Tierra no es un círculo perfecto y su eje está inclinado, así que durante diciembre el sol alcanza su punto más alto unos 30 segundos más tarde cada día. La puesta de sol se retrasa con ese desfase, mientras que por la mañana el sol sigue saliendo cada vez más tarde hasta principios de enero. Un temporizador de hora fija nunca puede seguir este detalle; la fórmula lo tiene en cuenta sola.
¿Cómo se calcula la puesta de sol?
El código usa las fórmulas solares aproximadas publicadas por la Administración Nacional Oceánica y Atmosférica de EE. UU. (NOAA). El cálculo solo necesita el día del año, la latitud y la longitud; no descarga ningún dato extra de internet. El resultado sale en minutos UTC y el código lo convierte a hora local con el ajuste de huso horario, así que también funciona bien en países con horario de verano. Por debajo de 60° de latitud la fórmula acierta con uno o dos minutos de margen; en zonas polares, cuando el sol no se pone o no sale en todo el día, el arcocoseno no está definido y el código lo comprueba aparte.
| Paso | Fórmula | Explicación |
|---|---|---|
| 1. Fracción del año | γ = 2π / 365 × (día − 1) | Convierte el día del año en radianes |
| 2. Ecuación del tiempo | eqtime = 229,18 × (0,000075 + 0,001868 cos γ − 0,032077 sin γ − 0,014615 cos 2γ − 0,040849 sin 2γ) | Diferencia entre la hora solar y la del reloj, entre −14 y +16 min aprox. a lo largo del año |
| 3. Declinación solar | δ = 0,006918 − 0,399912 cos γ + 0,070257 sin γ − ... | Unos −23,44° alrededor del 21 de diciembre |
| 4. Ángulo horario | ha = arccos(cos 90,833° / (cos φ cos δ) − tan φ tan δ) | 90,833°: refracción en el horizonte (0,567°) + radio del sol (0,267°) |
| 5. Puesta de sol | 720 − 4 × (longitud − ha) − eqtime | Minutos UTC; cada grado de longitud son 4 minutos |
Materiales
- Placa de desarrollo ESP32 (de 30 o 38 pines, da igual)
- Módulo de relé de 1 canal: con optoacoplador y contactos de 10 A 250 V CA; o un relé de estado sólido (SSR) silencioso
- Cargador USB de 5 V 1–2 A y cable USB para el ESP32
- Guirnalda: mejor una guirnalda LED de exterior de baja tensión (5–31 V) con su propio adaptador
- Caja estanca IP65, prensaestopas y regletas
- Unos cuantos cables jumper
Conexión: ESP32 y módulo de relé
| Módulo de relé | ESP32 | Nota |
|---|---|---|
| VCC | VIN (5 V) | La bobina del relé necesita 5 V; basta el pin VIN alimentado por USB |
| GND | GND | Masa común |
| IN | GPIO 26 | RELAY_PIN en el código; la mayoría de módulos activan con LOW |
| COM | Salida + del adaptador de la guirnalda | Entrada de la línea conmutada |
| NO (normalmente abierto) | Entrada + de la guirnalda | El circuito se cierra cuando el relé se activa |
| NC (normalmente cerrado) | Libre | No se usa |
Paso 1: ver la puesta de sol de hoy en el Monitor Serie
- En el Arduino IDE, instala el paquete esp32 desde el Gestor de placas y elige ESP32 Dev Module como placa.
- En el código de abajo, escribe el nombre y la contraseña de tu red en WIFI_SSID y WIFI_PASS.
- Cambia LATITUDE y LONGITUDE según tu ciudad; las longitudes oeste y las latitudes sur son negativas.
- Fuera de Turquía, elige la línea TZ_INFO de la tabla de husos horarios de más abajo; para España peninsular es "CET-1CEST,M3.5.0,M10.5.0/3".
- Sube el código, abre el Monitor Serie a 115200 baudios y compara las horas con la tabla.
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 más delicada del código es la conversión entre UTC y hora local. La fórmula da la puesta de sol en minutos desde la medianoche UTC de ese día. El código convierte primero el mediodía local de hoy en una marca de tiempo con mktime() y luego resta el resto de dividir entre 86400 para obtener la medianoche UTC de la misma fecha. A ese valor se le suman los minutos de la puesta de sol y localtime_r() pasa el resultado a tu huso horario. Partir del mediodía evita calcular el día equivocado durante las horas nocturnas en las que la fecha UTC y la local no coinciden.
Paso 2: el código completo con relé, apagado a medianoche y control web
El segundo sketch convierte el cálculo de la puesta de sol en un temporizador. Cada 10 segundos comprueba la hora; si ha cambiado el día, recalcula la salida y la puesta de sol, y en modo automático decide si las luces deben estar encendidas. La librería integrada WebServer sirve una pequeña página en el puerto 80: al abrir la IP del ESP32 en el navegador verás el estado de las luces, la salida y la puesta de sol de hoy y los enlaces AUTO, ON y OFF. El modo elegido se guarda en la flash con Preferences, así que tras un corte de luz el temporizador sigue en el mismo modo.
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, <);
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}Ajustes
| Ajuste | Valor por defecto | ¿Para qué sirve? |
|---|---|---|
| TZ_INFO | "<+03>-3" | Huso horario y regla del horario de verano (formato POSIX) |
| LATITUDE / LONGITUDE | 41.01 / 28.98 | Ubicación; longitud oeste y latitud sur en negativo |
| RELAY_PIN | 26 | Pin conectado a IN del módulo de relé |
| RELAY_ACTIVE_LOW | true | true si el módulo se activa con LOW, false si con HIGH |
| SUNSET_OFFSET_MIN | 0 | Desfase respecto a la puesta de sol; −15 enciende 15 min antes |
| OFF_MINUTE | 24 * 60 | Hora de apagado; para las 23:30 usa 23 * 60 + 30 |
| MORNING_ON_MINUTE | -1 | Encendido matinal; con 6 * 60 + 30 luce desde las 06:30 hasta el amanecer |
¿Cómo funciona el código?
applyState() es donde se toma la decisión. Si todavía no hay hora, las luces solo se encienden en modo ON; así se evita que se enciendan a una hora equivocada antes de que haya Wi-Fi. Con la hora válida se calcula el minuto del día y se comprueban dos condiciones: la ventana de la tarde va de la puesta de sol a la hora de apagado y la ventana opcional de la mañana va de la hora de encendido al amanecer. El relé solo conmuta cuando cambia el estado y cada cambio se escribe en el Monitor Serie, lo que facilita buscar fallos. setRelay() escribe en el pin el nivel correcto según RELAY_ACTIVE_LOW. En setup() el pin se pone en el nivel de apagado antes de configurarlo como salida; ese orden evita que el relé haga clic un instante al arrancar. Si se cae el Wi-Fi, el ESP32 sigue con su reloj interno y NTP vuelve a corregir la hora cuando regresa la conexión.
| Región | TZ_INFO |
|---|---|
| Turquía | <+03>-3 |
| Alemania, Austria, Italia, Francia, España peninsular | CET-1CEST,M3.5.0,M10.5.0/3 |
| Reino Unido, Irlanda, Portugal | GMT0BST,M3.5.0/1,M10.5.0 |
| Costa este de EE. UU. (Nueva York) | EST5EDT,M3.2.0,M11.1.0 |
| México (Ciudad de México) | CST6 |
Seguridad en exteriores
- Mejor baja tensión: Con guirnaldas LED de 5–31 V que traen su propio adaptador, pon el relé en la salida de baja tensión del adaptador y nunca tocarás la tensión de red.
- Caja y prensaestopas: Mete el ESP32 y el relé en una caja IP65, pasa los cables por prensaestopas y monta la caja con las entradas de cable hacia abajo para que no entre agua.
- Cálculo de corriente: Una guirnalda típica de 200 LED consume 10–20 W, menos de 0,1 A a 230 V. No te acercarás a los 10 A del relé, pero en módulos baratos el límite real es menor que el impreso, así que mantén la carga total por debajo de unos pocos amperios.
- Condensación: En las noches de invierno puede condensarse humedad dentro de la caja; añade un sobrecito de gel de sílice y fija la electrónica en la parte alta de la caja, no en el fondo.
- Sin cargas inductivas: Usa este temporizador solo para luces; la corriente de arranque de motores, estufas o compresores puede soldar los contactos del relé en poco tiempo.
Errores comunes y soluciones
| Problema | Causa | Solución |
|---|---|---|
| "Esperando NTP" no termina en el Monitor Serie | Wi-Fi sin conectar o puerto NTP bloqueado | Revisa el nombre de la red y la contraseña, acerca el ESP32 al router |
| La puesta de sol sale una hora exacta desplazada | TZ_INFO incorrecto o falta la regla del horario de verano | Usa la cadena POSIX correcta de la tabla |
| La puesta de sol sale varias horas desplazada | Signo de la longitud mal o latitud y longitud intercambiadas | Introduce la longitud oeste en negativo y revisa el orden |
| El relé nunca se suelta | El módulo de 5 V no se apaga del todo con un HIGH de 3,3 V | Separa JD-VCC, usa un módulo de 3,3 V o un transistor |
| Las luces destellan al arrancar | Pin de arranque u orden de pinMode | Usa un pin seguro como GPIO 26, primero digitalWrite y luego pinMode |
| La página web no abre | La IP ha cambiado | Haz una reserva DHCP en el router o usa mDNS |
| Las luces siguen encendidas pasada la medianoche | El modo se quedó en ON | Cambia a AUTO desde la página web |
Ideas de proyectos con este temporizador
- Sensor de luz de reserva: Si el Wi-Fi se cae durante mucho tiempo, detecta la oscuridad con una LDR y enciende las luces igualmente.
- Integración domótica: Publica el estado del relé por MQTT y contrólalo desde un panel de Home Assistant.
- Programación multicanal: Con una placa de relés de 4 canales, da horas de apagado distintas a las luces del balcón, del jardín y de la ventana.
- Efecto atardecer: Usa una tira WS2812B en lugar del relé y sube los colores poco a poco hasta un blanco cálido al ponerse el sol; el montaje de la tira está en luces del árbol de Navidad.
- Más proyectos de temporada: Para ideas que complementan este temporizador, mira la lista de proyectos navideños con Arduino.
Si quieres aprender las piezas de este temporizador una a una, mira en la app BlueGrays los proyectos de hora real por NTP con ESP32, servidor web asíncrono con ESP32 e iluminación inteligente con ESP32; cada uno incluye esquema, lista de conexiones y código explicado paso a paso. Combina esas piezas con el cálculo de la puesta de sol de este artículo y tus luces de Navidad se encenderán solas cada tarde a su hora.
Preguntas frecuentes
¿Cómo hacer que las luces de Navidad se enciendan solas al atardecer?
El método más preciso es usar una placa con Wi-Fi como el ESP32 para obtener la hora por NTP y calcular la puesta de sol del día con la latitud y la longitud. A esa hora la placa activa un relé que enciende las luces y las apaga a la hora que elijas. Una solución más sencilla es detectar la oscuridad con una LDR, pero las nubes y las farolas pueden engañarla.
¿El ESP32 obtiene la hora de la puesta de sol de internet?
No, de internet solo toma la hora del reloj mediante NTP. La puesta de sol la calcula él mismo con las fórmulas de la NOAA, para las que bastan el día del año, la latitud y la longitud. Por eso no hace falta ningún servicio meteorológico ni clave de API.
¿El temporizador sigue funcionando si se va internet?
Sí. Una vez que el ESP32 tiene la hora, sigue contando con su reloj interno y la deriva suele quedarse en unos pocos segundos al día. Cuando vuelve la conexión, NTP corrige la hora. Pero si el ESP32 se reinicia, el modo automático no encenderá las luces hasta que vuelva a tener la hora.
¿Funciona un módulo de relé con los 3,3 V del ESP32?
La mayoría de los módulos de relé de 5 V se activan con una señal de 3,3 V, pero algunos con optoacoplador que se activan con LOW no se sueltan del todo con un HIGH de 3,3 V. En ese caso se soluciona quitando el puente JD-VCC y alimentando el módulo aparte, comprando un módulo con disparo a 3,3 V o poniendo un transistor NPN en medio.
¿Qué relé usar para las luces de Navidad de exterior?
Para luces basta un módulo de relé mecánico con optoacoplador y contactos de 10 A 250 V CA; si no quieres oír el clic, usa un relé de estado sólido (SSR). Elijas el que elijas, mete la placa en una caja estanca y alimenta el lado de red desde una línea protegida con diferencial.
¿Se pueden encender las luces antes o después del atardecer?
Sí. SUNSET_OFFSET_MIN en el código fija el desfase en minutos: −15 enciende las luces 15 minutos antes de la puesta de sol y 20 las enciende 20 minutos después. Como el crepúsculo dura unos 30 minutos, un desfase positivo de 10–20 minutos suele dar el efecto más bonito.
Proyectos para hacer después de leer esto
Ver todos los proyectos
ESP32: hora real desde Internet con NTP
El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

ESP32 Luz de Noche con LDR
Luz nocturna en la que el LED se enciende automáticamente en la oscuridad y se apaga con la luz. Se utiliza el pin D0 (digital out) del módulo sensor LDR - el umbral de oscuridad se ajusta con el pequeño potenciómetro del módulo, el propio módulo genera la salida HIGH/LOW. ESP32 sólo lee esta señal con digitalRead(), el código es muy simple.

Control de la tira NeoPixel WS2812B con ESP32
Los LED direccionables WS2812B (NeoPixel) son LED RGB inteligentes que se encadenan y se controlan desde un solo pin de datos. Controlamos una tira WS2812B de 8 LED con la biblioteca Adafruit_NeoPixel y creamos un arcoíris fluido. La lógica de 3,3 V del ESP32 va bien con casi todos los WS2812B; si hay inestabilidad, mostramos la solución con una resistencia en serie de 470Ω y un condensador de 1000µF. La animación desplaza el tono en el espacio HSV.

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

Bombilla 220V con Pulsador (Push)
Mientras mantienes pulsado el botón, una bombilla real de 220 voltios se queda encendida, y se apaga en cuanto lo sueltas.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

