Guías · 9 min de lectura

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.

Módulo de relé para un temporizador de luces de Navidad con ESP32
Módulo de relé: el interruptor que conecta y desconecta la alimentación de la guirnalda con la señal de 3,3 V del 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.

CiudadLatitud, longitud1 dic10 dic21 dic31 dic
Estambul41,01 / 28,9817:3717:3617:3817:44
Ankara39,93 / 32,8617:2517:2317:2617:32
Esmirna38,42 / 27,1417:5117:5117:5317:59
Londres51,51 / -0,1315:5615:5215:5315:59
Berlín52,52 / 13,4115:5715:5315:5316:00
Múnich48,14 / 11,5816:2316:2016:2216:28
Viena48,21 / 16,3716:0416:0116:0216:08
Madrid40,42 / -3,7017:4917:4817:5117:57
París48,86 / 2,3516:5716:5416:5517:02
Roma41,90 / 12,5016:4016:3916:4116:47
Milán45,46 / 9,1916:4216:4016:4216:48
Nueva York40,71 / -74,0116:3016:2816:3116:37
Ciudad de México19,43 / -99,1317:5717:5918:0318: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.

PasoFórmulaExplicació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 tiempoeqtime = 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 horarioha = 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 sol720 − 4 × (longitud − ha) − eqtimeMinutos 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éESP32Nota
VCCVIN (5 V)La bobina del relé necesita 5 V; basta el pin VIN alimentado por USB
GNDGNDMasa común
INGPIO 26RELAY_PIN en el código; la mayoría de módulos activan con LOW
COMSalida + del adaptador de la guirnaldaEntrada de la línea conmutada
NO (normalmente abierto)Entrada + de la guirnaldaEl circuito se cierra cuando el relé se activa
NC (normalmente cerrado)LibreNo se usa
Hay una trampa habitual con los módulos de relé de 5 V con optoacoplador que se activan con LOW: como el nivel HIGH del ESP32 es de 3,3 V, el LED del optoacoplador puede no apagarse del todo y el relé nunca se suelta. Si te pasa, quita el puente JD-VCC y lleva 5 V a JD-VCC y 3,3 V a VCC, o usa un módulo con disparo a 3,3 V o un transistor NPN. Además, no conectes IN a pines de arranque como GPIO 0, 2, 12 y 15; cambian de estado un instante al arrancar el ESP32 y las luces dan un destello.

Paso 1: ver la puesta de sol de hoy en el Monitor Serie

  1. En el Arduino IDE, instala el paquete esp32 desde el Gestor de placas y elige ESP32 Dev Module como placa.
  2. En el código de abajo, escribe el nombre y la contraseña de tu red en WIFI_SSID y WIFI_PASS.
  3. Cambia LATITUDE y LONGITUDE según tu ciudad; las longitudes oeste y las latitudes sur son negativas.
  4. 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".
  5. Sube el código, abre el Monitor Serie a 115200 baudios y compara las horas con la tabla.
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 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.

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}

Ajustes

AjusteValor por defecto¿Para qué sirve?
TZ_INFO"<+03>-3"Huso horario y regla del horario de verano (formato POSIX)
LATITUDE / LONGITUDE41.01 / 28.98Ubicación; longitud oeste y latitud sur en negativo
RELAY_PIN26Pin conectado a IN del módulo de relé
RELAY_ACTIVE_LOWtruetrue si el módulo se activa con LOW, false si con HIGH
SUNSET_OFFSET_MIN0Desfase respecto a la puesta de sol; −15 enciende 15 min antes
OFF_MINUTE24 * 60Hora de apagado; para las 23:30 usa 23 * 60 + 30
MORNING_ON_MINUTE-1Encendido 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.

Si no quieres mirar la IP en el Monitor Serie cada vez, asigna al ESP32 una IP fija en el router (reserva DHCP) o accede a él por nombre con mDNS. Si prefieres introducir los datos del Wi-Fi desde el móvil en lugar de escribirlos en el código, puedes añadir a este sketch el método de ESP32 WiFiManager.
RegiónTZ_INFO
Turquía<+03>-3
Alemania, Austria, Italia, Francia, España peninsularCET-1CEST,M3.5.0,M10.5.0/3
Reino Unido, Irlanda, PortugalGMT0BST,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.
Si trabajas con 230 V, todas las conexiones deben ir dentro de una caja cerrada y aislada, el circuito debe alimentarse desde una línea con interruptor diferencial de 30 mA y la instalación debe hacerse sin tensión. Si no tienes experiencia con la instalación eléctrica, usa el relé solo en el lado de baja tensión o deja esta parte en manos de un electricista. Tampoco dejes el propio módulo de relé al alcance de la mano: las soldaduras del lado de los contactos llevan tensión de red.

Errores comunes y soluciones

ProblemaCausaSolución
"Esperando NTP" no termina en el Monitor SerieWi-Fi sin conectar o puerto NTP bloqueadoRevisa el nombre de la red y la contraseña, acerca el ESP32 al router
La puesta de sol sale una hora exacta desplazadaTZ_INFO incorrecto o falta la regla del horario de veranoUsa la cadena POSIX correcta de la tabla
La puesta de sol sale varias horas desplazadaSigno de la longitud mal o latitud y longitud intercambiadasIntroduce la longitud oeste en negativo y revisa el orden
El relé nunca se sueltaEl módulo de 5 V no se apaga del todo con un HIGH de 3,3 VSepara JD-VCC, usa un módulo de 3,3 V o un transistor
Las luces destellan al arrancarPin de arranque u orden de pinModeUsa un pin seguro como GPIO 26, primero digitalWrite y luego pinMode
La página web no abreLa IP ha cambiadoHaz una reserva DHCP en el router o usa mDNS
Las luces siguen encendidas pasada la medianocheEl modo se quedó en ONCambia 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.

Ver todos los proyectos
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

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.

4.5(13)
22
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

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

4.8(16)
26
Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
ES-37Avanzado
Premium

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.

4.3(6)
11
ESP32 Luz de Noche con LDR
ES-10Principiante
Premium

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.

4.6(17)
30
Control de la tira NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

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.

4.4(21)
38
ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
ES-29Avanzado
Premium

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

4.8(14)
23
Bombilla 220V con Pulsador (Push)
AR-19Avanzado
Premium

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.

4.4(30)
38