Guias · 10 min de leitura

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.

Módulo relé para um temporizador de luzes de Natal com ESP32
Módulo relé: a chave que liga e desliga a alimentação do cordão de luzes a partir do sinal de 3,3 V do 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.

CidadeLatitude, longitude1º dez10 dez21 dez31 dez
Istambul41,01 / 28,9817:3717:3617:3817:44
Ancara39,93 / 32,8617:2517:2317:2617:32
Esmirna38,42 / 27,1417:5117:5117:5317:59
Londres51,51 / -0,1315:5615:5215:5315:59
Berlim52,52 / 13,4115:5715:5315:5316:00
Munique48,14 / 11,5816:2316:2016:2216:28
Viena48,21 / 16,3716:0416:0116:0216:08
Madri40,42 / -3,7017:4917:4817:5117:57
Paris48,86 / 2,3516:5716:5416:5517:02
Roma41,90 / 12,5016:4016:3916:4116:47
Milão45,46 / 9,1916:4216:4016:4216:48
Nova York40,71 / -74,0116:3016:2816:3116:37
Cidade do México19,43 / -99,1317:5717:5918:0318: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.

PassoFórmulaExplicação
1. Fração do anoγ = 2π / 365 × (dia − 1)Converte o dia do ano em radianos
2. Equação do tempoeqtime = 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árioha = 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 sol720 − 4 × (longitude − ha) − eqtimeMinutos 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éESP32Observação
VCCVIN (5 V)A bobina do relé precisa de 5 V; o pino VIN alimentado pela USB é suficiente
GNDGNDGND comum
INGPIO 26RELAY_PIN no código; a maioria dos módulos aciona em LOW
COMSaída + da fonte das luzesEntrada da linha chaveada
NO (normalmente aberto)Entrada + do cordão de luzesO circuito fecha quando o relé é acionado
NC (normalmente fechado)LivreNão é usado
Existe uma armadilha comum nos módulos relé de 5 V com optoacoplador que acionam em LOW: como o nível HIGH do ESP32 é 3,3 V, o LED do optoacoplador pode não apagar por completo e o relé nunca desarma. Se isso acontecer, retire o jumper JD-VCC e alimente o JD-VCC com 5 V e o VCC com 3,3 V, ou use um módulo com acionamento em 3,3 V ou um transistor NPN. Também não ligue o IN do relé a pinos de strapping como GPIO 0, 2, 12 e 15; eles mudam de estado por um instante enquanto o ESP32 inicializa, e as luzes piscam rapidamente.

Passo 1: ver o pôr do sol de hoje no Monitor Serial

  1. Na Arduino IDE, instale o pacote esp32 pelo Gerenciador de Placas e selecione ESP32 Dev Module como placa.
  2. No código abaixo, coloque o nome e a senha da sua rede em WIFI_SSID e WIFI_PASS.
  3. Altere LATITUDE e LONGITUDE para a sua cidade; longitudes a oeste e latitudes ao sul são negativas.
  4. Fora da Turquia, escolha a linha de TZ_INFO na tabela de fusos horários abaixo.
  5. Carregue o código, abra o Monitor Serial em 115200 baud e compare os horários exibidos com a tabela.
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}

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.

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}

Configurações

ConfiguraçãoPadrãoPara que serve
TZ_INFO"<+03>-3"Fuso horário e regra do horário de verão (formato POSIX)
LATITUDE / LONGITUDE41.01 / 28.98Localização; longitude a oeste e latitude ao sul são negativas
RELAY_PIN26Pino ligado ao IN do módulo relé
RELAY_ACTIVE_LOWtruetrue se o módulo aciona em LOW, false se aciona em HIGH
SUNSET_OFFSET_MIN0Deslocamento em relação ao pôr do sol; −15 acende 15 min antes
OFF_MINUTE24 * 60Horário de desligamento; para 23:30 use 23 * 60 + 30
MORNING_ON_MINUTE-1Acendimento 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.

Se você não quiser ler o endereço IP no Monitor Serial toda vez, dê ao ESP32 um IP fixo no roteador (reserva de DHCP) ou acesse-o pelo nome com mDNS. Se preferir informar os dados do Wi-Fi pelo celular em vez de deixá-los fixos no código, você pode adicionar a este sketch o método de ESP32 WiFiManager.
RegiãoTZ_INFO
Turquia<+03>-3
Alemanha, Áustria, Itália, França, EspanhaCET-1CEST,M3.5.0,M10.5.0/3
Reino Unido, Irlanda, PortugalGMT0BST,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.
Se você for trabalhar com a tensão da rede elétrica, todas as conexões precisam ficar dentro de uma caixa fechada e isolada, o circuito tem de ser alimentado por uma linha com dispositivo DR (diferencial residual) de 30 mA e a instalação deve ser feita com a energia desligada. Se você não tem experiência com instalação elétrica, use o relé só no lado de baixa tensão ou peça para um eletricista fazer essa parte. Também não deixe o próprio módulo relé exposto; os pontos de solda do lado dos contatos ficam com a tensão da rede.

Problemas comuns e soluções

ProblemaCausaSolução
"Waiting for NTP" (aguardando NTP) nunca termina no Monitor SerialWi-Fi não conectado ou porta do NTP bloqueadaConfira o nome da rede e a senha, aproxime o ESP32 do roteador
O pôr do sol está exatamente uma hora erradoTZ_INFO errado ou regra do horário de verão faltandoUse a string POSIX correta da tabela
O pôr do sol está horas erradoSinal da longitude errado ou latitude e longitude trocadasInforme a longitude a oeste como negativa e confira a ordem
O relé nunca desarmaO módulo de 5 V não desliga totalmente com um HIGH de 3,3 VSepare o JD-VCC, use um módulo de 3,3 V ou um transistor
As luzes piscam rapidamente na inicializaçãoPino de strapping ou ordem do pinModeUse um pino seguro como o GPIO 26, chame digitalWrite antes do pinMode
A página web não abreO endereço IP mudouConfigure uma reserva de DHCP no roteador ou use mDNS
As luzes continuam acesas depois da meia-noiteO modo ficou em ONMude 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.

Ver todos os projetos
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

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.

4.5(13)
22
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
ES-37Avançado
Premium

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.

4.3(6)
11
Luz noturna com LDR e ESP32
ES-10Iniciante
Premium

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.

4.6(17)
30
Controle de fita WS2812B NeoPixel com ESP32
ES-24Intermediário
Premium

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.

4.9(19)
30
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38
ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
ES-29Avançado
Premium

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

4.8(14)
23
Acender uma lâmpada de 220V com botão de pressão
AR-19Avançado
Premium

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.

4.4(30)
38