Temporizador de luzes de Natal com ESP32: acenda automaticamente ao pôr do sol
Temporizador de luzes de Natal com ESP32: a hora via NTP e a sua localização dão o pôr do sol, e um relé liga as luzes e as desliga à meia-noite. Tabela de cidades, controle pela web e segurança.
A maior vantagem de usar um ESP32 como temporizador de luzes de Natal é que ele pode acender as luzes quando o sol realmente se põe onde você mora, e não em um horário fixo. O ESP32 se conecta ao Wi-Fi, pega a hora da internet via NTP, calcula o nascer e o pôr do sol daquele dia a partir da latitude e da longitude que você informar, liga o cordão de luzes com um módulo relé e o desliga sozinho à meia-noite. Além disso, uma pequena página web no celular permite ligar e desligar as luzes manualmente, e o modo escolhido fica guardado mesmo depois de uma queda de energia.
Neste guia, primeiro mostramos por que o pôr do sol muda todos os dias e quanto ele varia de uma cidade para outra; depois explicamos passo a passo a fórmula por trás do cálculo. Em seguida vêm dois sketches: o primeiro só mostra o nascer e o pôr do sol de hoje no Monitor Serial, o segundo é um temporizador completo com relé, desligamento à meia-noite e controle pela web. A última parte trata da segurança ao ar livre e dos erros mais comuns. Se quiser revisar o básico de NTP, dê uma olhada em relógio NTP com ESP32.

Por que o pôr do sol em vez de um horário fixo?
Um temporizador de tomada, mecânico ou digital, liga no mesmo horário todas as noites, mas o pôr do sol vai mudando ao longo da estação. Em Londres, o sol se põe às 16:35 em 1º de novembro, às 15:56 em 1º de dezembro e às 16:45 em 31 de janeiro: uma variação de cerca de 50 minutos durante a temporada de Natal. Um ajuste fixo em 16:15 acende as luzes ainda de dia no começo de novembro e no fim de janeiro; passe para 16:30 e, em meados de dezembro, elas acendem mais de meia hora depois de escurecer. A localização também pesa muito: em 21 de dezembro o sol se põe às 15:53 em Berlim e às 17:51 em Madri, embora as duas cidades estejam no mesmo fuso horário. A tabela abaixo mostra horários de pôr do sol calculados com a mesma fórmula usada no código; em geral, eles diferem dos valores publicados em um ou dois minutos.
| Cidade | Latitude, longitude | 1º dez | 10 dez | 21 dez | 31 dez |
|---|---|---|---|---|---|
| Istambul | 41,01 / 28,98 | 17:37 | 17:36 | 17:38 | 17:44 |
| Ancara | 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 |
| Berlim | 52,52 / 13,41 | 15:57 | 15:53 | 15:53 | 16:00 |
| Munique | 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 |
| Madri | 40,42 / -3,70 | 17:49 | 17:48 | 17:51 | 17:57 |
| Paris | 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ão | 45,46 / 9,19 | 16:42 | 16:40 | 16:42 | 16:48 |
| Nova York | 40,71 / -74,01 | 16:30 | 16:28 | 16:31 | 16:37 |
| Cidade do México | 19,43 / -99,13 | 17:57 | 17:59 | 18:03 | 18:08 |
A tabela esconde um detalhe interessante: embora 21 de dezembro seja o dia mais curto, o pôr do sol mais cedo acontece cerca de dez dias antes, na primeira quinzena de dezembro. O motivo é a equação do tempo: a órbita da Terra não é um círculo perfeito e o eixo dela é inclinado, então o momento em que o sol atinge o ponto mais alto no céu chega cerca de 30 segundos mais tarde a cada dia durante dezembro. O pôr do sol é empurrado para mais tarde junto com ele, enquanto de manhã o sol continua nascendo cada vez mais tarde até o começo de janeiro. Um temporizador de horário fixo nunca consegue captar essa sutileza; a fórmula leva isso em conta automaticamente.
Como o pôr do sol é calculado?
O código usa as fórmulas solares aproximadas publicadas pela Administração Oceânica e Atmosférica Nacional dos EUA (NOAA). O cálculo precisa apenas do dia do ano, da latitude e da longitude; nenhum dado extra é buscado na internet. O resultado sai em minutos UTC, que o código converte para a hora local de acordo com o seu fuso horário, então ele também funciona corretamente em países com horário de verão. Abaixo de 60° de latitude, a fórmula acerta com margem de um ou dois minutos; nas regiões polares, quando o sol não se põe ou não nasce o dia inteiro, o arccos fica indefinido, e o código verifica isso separadamente.
| Passo | Fórmula | Explicação |
|---|---|---|
| 1. Fração do ano | γ = 2π / 365 × (dia − 1) | Converte o dia do ano em radianos |
| 2. Equação do tempo | eqtime = 229,18 × (0,000075 + 0,001868 cos γ − 0,032077 sen γ − 0,014615 cos 2γ − 0,040849 sen 2γ) | Diferença entre a hora do relógio de sol e a hora do relógio comum, de cerca de −14 a +16 min ao longo do ano |
| 3. Declinação solar | δ = 0,006918 − 0,399912 cos γ + 0,070257 sen γ − ... | Cerca de −23,44° por volta de 21 de dezembro |
| 4. Ângulo horário | ha = arccos(cos 90,833° / (cos φ cos δ) − tan φ tan δ) | 90,833°: refração no horizonte (0,567°) + raio do sol (0,267°) |
| 5. Pôr do sol | 720 − 4 × (longitude − ha) − eqtime | Minutos UTC; cada grau de longitude equivale a 4 minutos |
Lista de materiais
- Placa de desenvolvimento ESP32 (de 30 ou 38 pinos, tanto faz)
- Módulo relé de 1 canal: com isolação por optoacoplador e contatos para 10 A 250 V AC; ou um relé de estado sólido (SSR), que é silencioso
- Fonte USB de 5 V 1–2 A e um cabo USB para o ESP32
- Cordão de luzes: de preferência um cordão de LEDs para uso externo de baixa tensão (5–31 V), com fonte própria
- Caixa de passagem IP65, prensa-cabos e bornes de conexão
- Alguns jumpers
Ligação: ESP32 e módulo relé
| Módulo relé | ESP32 | Observação |
|---|---|---|
| VCC | VIN (5 V) | A bobina do relé precisa de 5 V; o pino VIN alimentado pela USB é suficiente |
| GND | GND | GND comum |
| IN | GPIO 26 | RELAY_PIN no código; a maioria dos módulos aciona em LOW |
| COM | Saída + da fonte das luzes | Entrada da linha chaveada |
| NO (normalmente aberto) | Entrada + do cordão de luzes | O circuito fecha quando o relé é acionado |
| NC (normalmente fechado) | Livre | Não é usado |
Passo 1: ver o pôr do sol de hoje no Monitor Serial
- Na Arduino IDE, instale o pacote esp32 pelo Gerenciador de Placas e selecione ESP32 Dev Module como placa.
- No código abaixo, coloque o nome e a senha da sua rede em WIFI_SSID e WIFI_PASS.
- Altere LATITUDE e LONGITUDE para a sua cidade; longitudes a oeste e latitudes ao sul são negativas.
- Fora da Turquia, escolha a linha de TZ_INFO na tabela de fusos horários abaixo.
- Carregue o código, abra o Monitor Serial em 115200 baud e compare os horários exibidos com a tabela.
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}A parte mais delicada do código é a conversão entre UTC e hora local. A fórmula dá o pôr do sol em minutos contados a partir da meia-noite UTC daquele dia. Primeiro, o código transforma o meio-dia local de hoje em um timestamp com mktime() e, em seguida, subtrai o resto da divisão por 86400 para achar a meia-noite UTC da mesma data. Os minutos do pôr do sol são somados a esse valor, e localtime_r() converte o resultado para o seu fuso horário. Partir do meio-dia elimina o risco de calcular o dia errado nas horas da noite em que a data UTC e a data local são diferentes.
Passo 2: o código completo com relé, desligamento à meia-noite e controle pela web
O segundo sketch transforma o cálculo do pôr do sol em um temporizador. A cada 10 segundos ele confere a hora; se o dia mudou, recalcula o nascer e o pôr do sol e, no modo automático, decide se as luzes devem estar acesas. A biblioteca embutida WebServer serve uma pequena página na porta 80: abra o endereço IP do ESP32 no navegador e você verá o estado das luzes, o nascer e o pôr do sol de hoje e os links AUTO, ON e OFF. O modo selecionado é gravado na memória flash com Preferences, então, depois de uma queda de energia, o temporizador continua no mesmo 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}Configurações
| Configuração | Padrão | Para que serve |
|---|---|---|
| TZ_INFO | "<+03>-3" | Fuso horário e regra do horário de verão (formato POSIX) |
| LATITUDE / LONGITUDE | 41.01 / 28.98 | Localização; longitude a oeste e latitude ao sul são negativas |
| RELAY_PIN | 26 | Pino ligado ao IN do módulo relé |
| RELAY_ACTIVE_LOW | true | true se o módulo aciona em LOW, false se aciona em HIGH |
| SUNSET_OFFSET_MIN | 0 | Deslocamento em relação ao pôr do sol; −15 acende 15 min antes |
| OFF_MINUTE | 24 * 60 | Horário de desligamento; para 23:30 use 23 * 60 + 30 |
| MORNING_ON_MINUTE | -1 | Acendimento pela manhã; com 6 * 60 + 30 as luzes ficam acesas das 06:30 até o nascer do sol |
Como o código funciona?
É em applyState() que a decisão é tomada. Se a hora ainda não foi recebida, as luzes só acendem no modo ON; isso evita que elas liguem no horário errado antes de o Wi-Fi conectar. Quando a hora é válida, o código calcula o minuto do dia e verifica duas condições: a janela da noite vai do pôr do sol até o horário de desligamento, e a janela opcional da manhã vai do horário de acendimento até o nascer do sol. O relé só é chaveado quando o estado muda, e cada mudança é mostrada no Monitor Serial, o que facilita a solução de problemas. setRelay() escreve o nível correto no pino de acordo com RELAY_ACTIVE_LOW. Em setup(), o pino é colocado no nível de desligado antes de ser configurado como saída; essa ordem impede que o relé dê um clique por um instante na inicialização. Se o Wi-Fi cair, o ESP32 continua funcionando com o relógio interno, e o NTP corrige a hora de novo quando a conexão voltar.
| Região | TZ_INFO |
|---|---|
| Turquia | <+03>-3 |
| Alemanha, Áustria, Itália, França, Espanha | CET-1CEST,M3.5.0,M10.5.0/3 |
| Reino Unido, Irlanda, Portugal | GMT0BST,M3.5.0/1,M10.5.0 |
| Leste dos EUA (Nova York) | EST5EDT,M3.2.0,M11.1.0 |
| México (Cidade do México) | CST6 |
Segurança ao ar livre
- Prefira baixa tensão: com cordões de LEDs de 5–31 V que vêm com fonte própria, coloque o relé na saída de baixa tensão da fonte e você nunca vai mexer com a tensão da rede elétrica.
- Caixa e prensa-cabos: coloque o ESP32 e o relé em uma caixa IP65, passe os cabos pelos prensa-cabos e instale a caixa com as entradas dos cabos voltadas para baixo, para que a água não escorra para dentro.
- Conta da corrente: um cordão típico de 200 LEDs consome 10–20 W, menos de 0,1 A em 230 V. Você nem chega perto do limite de 10 A do relé, mas em módulos baratos o limite real é menor que o impresso, então mantenha a carga total abaixo de alguns ampères.
- Condensação: nas noites de inverno, a umidade pode condensar dentro da caixa; coloque um pequeno sachê de sílica gel e fixe a eletrônica na parte de cima da caixa, e não no fundo.
- Nada de cargas indutivas: use este temporizador só para luzes; a corrente de partida de motores, aquecedores ou compressores pode soldar os contatos do relé em pouco tempo.
Problemas comuns e soluções
| Problema | Causa | Solução |
|---|---|---|
| "Waiting for NTP" (aguardando NTP) nunca termina no Monitor Serial | Wi-Fi não conectado ou porta do NTP bloqueada | Confira o nome da rede e a senha, aproxime o ESP32 do roteador |
| O pôr do sol está exatamente uma hora errado | TZ_INFO errado ou regra do horário de verão faltando | Use a string POSIX correta da tabela |
| O pôr do sol está horas errado | Sinal da longitude errado ou latitude e longitude trocadas | Informe a longitude a oeste como negativa e confira a ordem |
| O relé nunca desarma | O módulo de 5 V não desliga totalmente com um HIGH de 3,3 V | Separe o JD-VCC, use um módulo de 3,3 V ou um transistor |
| As luzes piscam rapidamente na inicialização | Pino de strapping ou ordem do pinMode | Use um pino seguro como o GPIO 26, chame digitalWrite antes do pinMode |
| A página web não abre | O endereço IP mudou | Configure uma reserva de DHCP no roteador ou use mDNS |
| As luzes continuam acesas depois da meia-noite | O modo ficou em ON | Mude para AUTO pela página web |
Ideias de projetos com este temporizador
- Sensor de luz como reserva: se o Wi-Fi ficar fora do ar por muito tempo, detecte o escuro com um LDR e acenda as luzes mesmo assim.
- Integração com a casa inteligente: publique o estado do relé via MQTT e controle-o por um painel do Home Assistant.
- Programação em vários canais: com uma placa de relés de 4 canais, defina horários de desligamento diferentes para as luzes da varanda, do jardim e da janela.
- Efeito de pôr do sol: use uma fita WS2812B no lugar do relé e faça as cores passarem devagar até o branco quente ao pôr do sol; a montagem da fita está em LEDs na árvore de Natal.
- Mais projetos da temporada: para ideias que complementam este temporizador, veja a lista de projetos de Natal com Arduino.
Se quiser aprender as partes deste temporizador uma de cada vez, veja no app BlueGrays os projetos de relógio de tempo real via NTP com ESP32, servidor web assíncrono com ESP32 e iluminação inteligente com ESP32; cada um vem com esquema do circuito, lista de ligações e código explicado passo a passo. Junte essas peças com o cálculo do pôr do sol deste post, e suas luzes de Natal vão acender sozinhas, na hora certa, todas as noites.
Perguntas frequentes
Como fazer as luzes de Natal acenderem automaticamente ao pôr do sol?
O método mais preciso é usar uma placa com Wi-Fi, como o ESP32, para pegar a hora via NTP e calcular o pôr do sol daquele dia a partir da latitude e da longitude. Nesse horário, a placa aciona um relé para acender as luzes e as desliga no horário que você escolher. Uma solução mais simples é detectar o escuro com um LDR, mas nuvens e postes de iluminação podem confundir a leitura.
O ESP32 pega o horário do pôr do sol na internet?
Não, ele só pega a hora do relógio na internet via NTP. O pôr do sol é calculado pelo próprio ESP32 com as fórmulas da NOAA, que precisam apenas do dia do ano, da latitude e da longitude. Por isso, não é preciso nenhum serviço de previsão do tempo nem chave de API.
O temporizador continua funcionando se a internet cair?
Sim. Depois que o ESP32 recebe a hora, ele continua contando com o relógio interno, e o desvio normalmente fica em poucos segundos por dia. Quando a conexão volta, o NTP corrige a hora de novo. Mas, se o ESP32 reiniciar, o modo automático não acende as luzes até receber a hora.
Um módulo relé funciona com os 3,3 V do ESP32?
A maioria dos módulos relé de 5 V aciona com um sinal de 3,3 V, mas alguns módulos com optoacoplador que acionam em LOW não desarmam totalmente com um HIGH de 3,3 V. Nesse caso, retirar o jumper JD-VCC e alimentar o módulo separadamente, comprar um módulo com acionamento em 3,3 V ou colocar um transistor NPN resolve o problema.
Qual relé usar para luzes de Natal ao ar livre?
Para luzes, basta um módulo relé mecânico com isolação por optoacoplador e contatos para 10 A 250 V AC; se você não quiser o clique, use um relé de estado sólido (SSR). Seja qual for a escolha, coloque a placa em uma caixa à prova d'água e alimente o lado da rede elétrica por uma linha protegida por dispositivo DR.
Dá para acender as luzes antes ou depois do pôr do sol?
Sim. SUNSET_OFFSET_MIN no código define o deslocamento em minutos: −15 acende as luzes 15 minutos antes do pôr do sol e 20 acende 20 minutos depois. Como o crepúsculo dura cerca de 30 minutos, um deslocamento positivo de 10–20 minutos costuma dar o efeito mais bonito.
Projetos para montar depois desta leitura
Ver todos os projetos
Hora exata pela internet com ESP32 e NTP
O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.

Luz noturna com LDR e ESP32
Uma luz noturna em que o LED acende automaticamente no escuro e apaga na claridade. Usamos o pino D0 (saída digital) do módulo sensor LDR. O pequeno potenciômetro no módulo ajusta o limiar de escuridão, e o próprio módulo gera a saída HIGH/LOW. O ESP32 apenas lê esse sinal com digitalRead(), deixando o código bem simples.

Controle de fita WS2812B NeoPixel com ESP32
Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
Neste projeto, adicionamos o serviço mDNS (Multicast DNS) ao ESP32 para acessar o dispositivo por um nome de host fácil de ler, como bluegrays-esp.local, em vez de um endereço IP. Mesmo que o IP atribuído pelo DHCP mude, você pode acessar o dispositivo pelo mesmo nome. Também executamos um pequeno servidor web no dispositivo para enviar comandos de controle do LED pelo navegador no endereço http://bluegrays-esp.local/.

Acender uma lâmpada de 220V com botão de pressão
Enquanto você mantém o botão pressionado, uma lâmpada de 220 volts fica acesa e apaga assim que você solta.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

