Tomada inteligente com ESP32: tutorial com relé, painel web e timer NTP
Monte uma tomada inteligente Wi-Fi com ESP32: ligação do relé e do HLK-PM01, painel web para ligar e desligar, timer com horário NTP, limites de carga e regras de segurança para 230 V, com código completo.
Uma tomada inteligente com ESP32 transforma uma tomada comum em um dispositivo que você liga e desliga pelo celular ou pelo computador via Wi-Fi, e que pode até funcionar sozinho em horários definidos. A ideia é simples: o ESP32 se conecta à rede da sua casa e oferece um pequeno painel web; quando você aperta “Ligar” no painel, o ESP32 aciona um relé, e o relé fecha a fase da tomada para alimentar o aparelho conectado. Para alimentar todo o conjunto pela rede elétrica, um pequeno módulo AC-DC chamado HLK-PM01 converte 230 V em 5 V, então você não precisa de um adaptador separado dentro da caixa.
Neste guia você vai ver, passo a passo, como escolher as peças, calcular o consumo, fazer as ligações, escrever o código com painel web e adicionar um timer de contagem regressiva e uma programação diária com NTP. Mas atenção: este projeto trabalha com a tensão da rede de 230 V e não perdoa erros. Por isso, há uma regra principal em todo o artigo: teste tudo primeiro em baixa tensão; quando o código e as ligações funcionarem sem falhas, passe para a rede elétrica seguindo as regras de caixa e isolação. Se você não tem experiência com instalações elétricas, faça a última etapa sob a supervisão de alguém que tenha.

O que é uma tomada inteligente com ESP32 e como ela funciona?
As tomadas inteligentes comerciais têm os mesmos três blocos: um microcontrolador com Wi-Fi, um elemento de chaveamento (geralmente um relé) e uma pequena fonte que gera baixa tensão a partir da rede. Na nossa versão, o ESP32 cuida da conexão Wi-Fi, do servidor web e do relógio. O relé chaveia a carga de 230 V mantendo-a eletricamente isolada do fraco sinal de 3,3 V do ESP32; quando a corrente passa pela bobina, o contato interno fecha e você percebe isso por um “clique” audível. O HLK-PM01 é uma fonte chaveada encapsulada, com isolação entre entrada e saída; com entrada de 100–240 V AC, ela fornece 5 V DC com até 3 W (600 mA). Para conhecer a estrutura interna e o circuito de proteção, veja o artigo conversor AC-DC HLK-PM01.
| Peça | Função | Valor importante |
|---|---|---|
| ESP32 DevKit | Wi-Fi, painel web, timer e relógio NTP | Lógica de 3,3 V, pico de 250–350 mA ao transmitir Wi-Fi |
| Módulo relé de 5 V com 1 canal | Abre e fecha a fase da tomada | Contato: 10 A 250 V AC (SRD-05VDC-SL-C) |
| HLK-PM01 | Converte 230 V AC em 5 V DC | 5 V, 600 mA (3 W), isolado |
| Fusível e varistor | Protegem a entrada do HLK-PM01 contra curto-circuito e sobretensão | Por exemplo, fusível retardado de 0,5 A e varistor de 275 V AC (10D431K) |
| Botão de pressão | Liga e desliga manualmente pela caixa | GPIO 27, pull-up interno |
| Caixa de projeto e tomada com aterramento | Isolação e proteção contra toque | Plástico antichama UL94 V-0 |

Consumo: o HLK-PM01 dá conta?
| Consumidor | Corrente típica (linha de 5 V) | Observação |
|---|---|---|
| ESP32 (Wi-Fi conectado, ocioso) | 80–120 mA | O regulador da placa reduz 5 V para 3,3 V |
| ESP32 (pico de transmissão Wi-Fi) | 250–350 mA (curta duração) | Deve ser suavizado com capacitor |
| Bobina do relé (5 V) | 70–90 mA | Só enquanto o relé está acionado |
| LEDs de status | 5–10 mA | LEDs do módulo e da placa |
| Total (pior caso) | Cerca de 450 mA | Limite do HLK-PM01: 600 mA |
Como a tabela mostra, uma tomada inteligente com um só relé cabe na capacidade de 600 mA do HLK-PM01, mas a margem não é grande. Por isso, colocar um capacitor eletrolítico de pelo menos 470 µF perto do pino 5V (VIN) do ESP32, com um capacitor cerâmico de 100 nF ao lado, evita que a tensão caia e a placa reinicie durante os picos de corrente do Wi-Fi e no instante em que o relé aciona. Se você usar um relé de quatro canais e acionar todos ao mesmo tempo, só as bobinas passam de 300 mA; nesse caso, escolha um módulo mais forte, como o HLK-5M05 de 5 W. Você pode conferir rapidamente os cálculos de corrente e potência com a calculadora da lei de Ohm.
Esquema de ligação: ESP32, relé e HLK-PM01
| Terminal | Liga em | Observação |
|---|---|---|
| Entradas AC do HLK-PM01 | L e N da rede (depois do fusível e do varistor) | No compartimento de alta tensão da caixa |
| HLK-PM01 +Vo | 5V (VIN) do ESP32 e VCC do módulo relé | Desconecte a rede ao carregar o programa |
| HLK-PM01 -Vo | GND do ESP32 e GND do módulo relé | GND comum |
| IN do relé | GPIO 26 do ESP32 | Pino seguro que não gera sinal na inicialização |
| Botão | GPIO 27 e GND | INPUT_PULLUP, sem resistor externo |
| LED de status | GPIO 2 | Integrado na maioria das placas DevKit |
| COM do relé | Fase da rede (L), depois do fusível | Só a fase é chaveada |
| NO do relé | Terminal de fase da tomada | Normalmente aberto: a tomada fica sem energia quando o relé desarma |
| Neutro (N) e terra (PE) | Direto para os terminais N e terra da tomada | Não passam pelo relé, seguem sem interrupção |
Há um motivo para termos escolhido o GPIO 26 para o relé: os GPIO 0, 2, 12 e 15 são pinos de inicialização (strapping) e afetam como a placa dá partida; os GPIO 1 e 3 são reservados para a porta serial, os 6–11 para a memória flash interna, e os GPIO 5 e 14 também geram pulsos curtos na inicialização. O GPIO 26 não faz nada disso. O GPIO 2 não tem problema porque só aciona o LED da placa como saída. Usar o terminal NO (normalmente aberto) do relé também é importante: quando o ESP32 está desligado, reiniciando ou com defeito, o relé desarma e a tomada fica sem energia. Se você usar o terminal NC, acontece o contrário e, em caso de falha, o aparelho continua funcionando.
Teste primeiro em baixa tensão
- Alimente o ESP32 só pelo cabo USB; não conecte o HLK-PM01 nesta etapa. Ligue o VCC do módulo relé ao pino 5V (VIN) do ESP32, o GND ao GND e o IN ao GPIO 26.
- Em vez de 230 V, ligue uma carga de baixa tensão aos terminais COM e NO do relé: um adaptador de 12 V com um pedaço curto de fita LED, ou um LED alimentado por 5 V com um resistor de 220 Ω, já basta.
- Carregue o código de teste abaixo e abra o Monitor Serial a 115200 baud; o relé deve dar um clique a cada 2 segundos e o LED deve piscar.
- Se o relé funcionar ao contrário (a carga apaga enquanto a tela mostra “ON”), mude o valor de RELAY_ACTIVE_LOW no código.
- Depois, carregue o código com painel web, ligue e desligue pelo celular e teste o timer; reinicie o ESP32 e confira se o relé começa desligado e se a placa não trava quando o Wi-Fi cai.
- Deixe o conjunto funcionando um dia inteiro em baixa tensão e observe se a programação NTP liga e desliga nos horários certos; só depois disso passe para a instalação na rede elétrica.
1// Röle testi / Relay test
2const int RELAY_PIN = 26; // Röle IN pini / Relay IN pin
3const bool RELAY_ACTIVE_LOW = true; // Çoğu modül LOW ile çeker / Most modules energize on LOW
4
5void relaySet(bool on) {
6 if (RELAY_ACTIVE_LOW) digitalWrite(RELAY_PIN, on ? LOW : HIGH);
7 else digitalWrite(RELAY_PIN, on ? HIGH : LOW);
8}
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(RELAY_PIN, OUTPUT);
13 relaySet(false); // kapalı başla / start off
14}
15
16void loop() {
17 relaySet(true);
18 Serial.println("Role ACIK / Relay ON");
19 delay(2000);
20 relaySet(false);
21 Serial.println("Role KAPALI / Relay OFF");
22 delay(2000);
23}A função relaySet() traduz os comandos “ligar” e “desligar” para a lógica de acionamento do módulo. A maioria dos módulos relé do mercado é ativa em LOW: o relé aciona quando o pino IN vai para GND. Controlar essa lógica invertida com uma única constante (RELAY_ACTIVE_LOW), em vez de pensar nela em todo o código, evita erros. Há outra vantagem: enquanto o ESP32 inicializa ou reinicia, os pinos ficam como entrada, e um módulo ativo em LOW com o pino IN flutuando não aciona sozinho nesse momento. Para a estrutura interna do relé e o circuito de acionamento, dê uma olhada em O que é um módulo relé?.
Código da tomada inteligente com painel web
Se o teste funcionou, você pode passar para o código principal. A biblioteca WebServer, que já vem com o core do Arduino para ESP32, não precisa de instalação extra e funciona igual nas versões 2.x e 3.x do core. O código oferece um painel de controle na página inicial, comandos em /on, /off, /toggle e /timer?min=30, e o estado da tomada em JSON em /state. O painel consulta /state a cada 2 segundos, então você também vê no celular as mudanças feitas pelo botão da caixa ou pela programação. Não esqueça de trocar o nome e a senha do Wi-Fi no início do código pelos da sua rede; o ESP32 só se conecta a redes de 2,4 GHz. Se quiser atualização instantânea, veja Servidor web ESP32 e WebSocket.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESPmDNS.h>
4#include <time.h>
5
6const char* WIFI_SSID = "WIFI_ADI"; // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "WIFI_SIFRESI"; // Wi-Fi şifren / your Wi-Fi password
8
9const int RELAY_PIN = 26; // Röle IN / Relay IN
10const int BUTTON_PIN = 27; // Yerel buton / Local button
11const int LED_PIN = 2; // Durum LED'i / Status LED
12const bool RELAY_ACTIVE_LOW = true; // LOW tetiklemeli modül / Active-LOW module
13
14// Günlük program (gece yarısından itibaren dakika) / Daily schedule (minutes after midnight)
15int onMinute = 18 * 60 + 30; // 18:30 aç / turn on
16int offMinute = 23 * 60; // 23:00 kapat / turn off
17bool scheduleEnabled = true;
18
19WebServer server(80);
20bool relayOn = false;
21bool timerActive = false;
22unsigned long offAtMs = 0;
23int lastCheckedMinute = -1;
24
25const char PAGE[] PROGMEM = R"rawliteral(
26<!DOCTYPE html><html><head><meta charset="utf-8">
27<meta name="viewport" content="width=device-width,initial-scale=1">
28<title>Akıllı Priz</title>
29<style>
30body{font-family:sans-serif;text-align:center;background:#0f172a;color:#e2e8f0}
31button{font-size:20px;margin:6px;padding:12px 22px;border:0;border-radius:10px;color:#fff}
32.on{background:#16a34a}.off{background:#dc2626}.t{background:#2563eb}
33</style></head><body>
34<h2>ESP32 Akıllı Priz</h2>
35<p id="s">...</p><p id="z"></p>
36<button class="on" onclick="go('/on')">AÇ</button>
37<button class="off" onclick="go('/off')">KAPAT</button><br>
38<button class="t" onclick="go('/timer?min=15')">15 dk</button>
39<button class="t" onclick="go('/timer?min=30')">30 dk</button>
40<button class="t" onclick="go('/timer?min=60')">60 dk</button>
41<script>
42function show(d){
43 document.getElementById('s').textContent='Priz: '+(d.on?'AÇIK':'KAPALI');
44 document.getElementById('z').textContent='Saat '+d.time+(d.left>0?' | Kalan: '+d.left+' dk':'');
45}
46function go(u){fetch(u).then(r=>r.json()).then(show);}
47setInterval(()=>go('/state'),2000);
48go('/state');
49</script></body></html>
50)rawliteral";
51
52void relaySet(bool on) {
53 relayOn = on;
54 if (RELAY_ACTIVE_LOW) digitalWrite(RELAY_PIN, on ? LOW : HIGH);
55 else digitalWrite(RELAY_PIN, on ? HIGH : LOW);
56 digitalWrite(LED_PIN, on ? HIGH : LOW);
57}
58
59String timeText() {
60 struct tm t;
61 if (!getLocalTime(&t, 10)) return "--:--"; // saat henüz yok / time not synced yet
62 char buf[16];
63 snprintf(buf, sizeof(buf), "%02d:%02d", t.tm_hour, t.tm_min);
64 return String(buf);
65}
66
67long minutesLeft() {
68 if (!timerActive) return 0;
69 long ms = (long)(offAtMs - millis());
70 return ms > 0 ? (ms + 59999L) / 60000L : 0;
71}
72
73void sendState() {
74 String json = "{\"on\":";
75 json += relayOn ? "true" : "false";
76 json += ",\"time\":\"";
77 json += timeText();
78 json += "\",\"left\":";
79 json += String(minutesLeft());
80 json += "}";
81 server.send(200, "application/json", json);
82}
83
84void handleOn() { timerActive = false; relaySet(true); sendState(); }
85void handleOff() { timerActive = false; relaySet(false); sendState(); }
86
87void handleTimer() {
88 int m = server.arg("min").toInt();
89 if (m < 1 || m > 720) { // 1-720 dakika / 1-720 minutes
90 server.send(400, "text/plain", "min 1-720");
91 return;
92 }
93 relaySet(true);
94 offAtMs = millis() + (unsigned long)m * 60000UL;
95 timerActive = true;
96 sendState();
97}
98
99void setup() {
100 Serial.begin(115200);
101 pinMode(RELAY_PIN, OUTPUT);
102 pinMode(LED_PIN, OUTPUT);
103 pinMode(BUTTON_PIN, INPUT_PULLUP);
104 relaySet(false); // güvenli başlangıç: kapalı / safe start: off
105
106 WiFi.mode(WIFI_STA);
107 WiFi.setAutoReconnect(true);
108 WiFi.begin(WIFI_SSID, WIFI_PASS);
109 unsigned long t0 = millis();
110 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 20000) {
111 delay(500);
112 Serial.print(".");
113 }
114 Serial.println();
115 Serial.print("IP: ");
116 Serial.println(WiFi.localIP());
117
118 configTzTime("<+03>-3", "pool.ntp.org", "time.google.com"); // Türkiye UTC+3 / Turkey UTC+3
119
120 if (MDNS.begin("akillipriz")) {
121 Serial.println("http://akillipriz.local");
122 }
123
124 server.on("/", []() { server.send(200, "text/html; charset=utf-8", PAGE); });
125 server.on("/state", sendState);
126 server.on("/on", handleOn);
127 server.on("/off", handleOff);
128 server.on("/toggle", []() { timerActive = false; relaySet(!relayOn); sendState(); });
129 server.on("/timer", handleTimer);
130 server.begin();
131}
132
133void loop() {
134 server.handleClient();
135
136 // Yerel buton, basit debounce / Local button, simple debounce
137 static bool lastBtn = HIGH;
138 static unsigned long lastChange = 0;
139 bool btn = digitalRead(BUTTON_PIN);
140 if (btn != lastBtn && millis() - lastChange > 50) {
141 lastChange = millis();
142 lastBtn = btn;
143 if (btn == LOW) { // basıldı / pressed
144 timerActive = false;
145 relaySet(!relayOn);
146 }
147 }
148
149 // Geri sayım zamanlayıcısı / Countdown timer
150 if (timerActive && (long)(millis() - offAtMs) >= 0) {
151 timerActive = false;
152 relaySet(false);
153 }
154
155 // NTP saatine göre günlük program / Daily schedule from NTP time
156 static unsigned long lastTick = 0;
157 if (millis() - lastTick >= 1000) {
158 lastTick = millis();
159 struct tm t;
160 if (scheduleEnabled && getLocalTime(&t, 0)) {
161 int nowMin = t.tm_hour * 60 + t.tm_min;
162 if (nowMin != lastCheckedMinute) { // her dakika bir kez / once per minute
163 lastCheckedMinute = nowMin;
164 if (nowMin == onMinute) relaySet(true);
165 if (nowMin == offMinute) { timerActive = false; relaySet(false); }
166 }
167 }
168 }
169}| Trecho do código | O que faz |
|---|---|
| relaySet(bool on) (controle do relé) | Atualiza juntos o relé, o LED de status e a variável relayOn |
| server.on("/timer", ...) (rota do timer) | Com um parâmetro como ?min=30, liga a tomada e desliga quando o tempo acaba (1–720 minutos) |
| minutesLeft() (tempo restante) | Calcula o tempo restante do timer em minutos, arredondando para cima |
| (long)(millis() - offAtMs) >= 0 (comparação de tempo) | Uma comparação de tempo que resiste ao estouro do millis() (cerca de 49,7 dias) |
| configTzTime("<+03>-3", ...) (fuso horário) | Obtém a hora dos servidores NTP e converte para o horário da Turquia (UTC+3) |
| lastCheckedMinute (último minuto verificado) | Garante que a verificação da programação rode só uma vez por minuto; não sobrescreve um comando que você deu manualmente |
| MDNS.begin("akillipriz") (nome na rede) | Permite acessar o painel em http://akillipriz.local em vez do IP |
Funcionamento automático com timer e NTP
O ESP32 não tem relógio com bateria; ao ligar, ele não sabe que horas são. A chamada configTzTime() inicia o cliente SNTP em segundo plano, obtém a hora UTC de servidores como pool.ntp.org e a converte para o horário local de acordo com a string de fuso horário que você informar. Depois de receber a hora, o ESP32 continua contando com seu próprio temporizador e, por padrão, sincroniza de novo a cada hora. Como a Turquia não usa horário de verão desde 2016, a string “<+03>-3” basta; no formato POSIX o sinal é escrito invertido, então UTC+3 aparece como -3. Para detalhes, veja Hora da internet no ESP32 com NTP.
O código tem dois tipos de funcionamento automático. O primeiro é o timer de contagem regressiva: o botão “30 min” do painel liga a tomada e desliga quando o tempo acaba; é ideal para aparelhos que você não quer deixar ligados por engano, como carregador, bomba de ar de aquário ou ventilador do quarto. O segundo é a programação diária: todo dia a tomada liga em onMinute e desliga em offMinute. Como a programação só age no momento em que o minuto muda e exatamente naquele minuto, uma luminária que você desliga manualmente às 20:00, por exemplo, fica desligada até o próximo horário de ligar. Pelo mesmo motivo, programações que passam da meia-noite, como ligar às 22:00 e desligar às 06:00, também funcionam sem problemas.
| Ajuste | Valor de exemplo | Resultado |
|---|---|---|
| onMinute (horário de ligar) | 18 * 60 + 30 | Liga todo dia às 18:30 |
| offMinute (horário de desligar) | 23 * 60 | Desliga todo dia às 23:00 |
| onMinute e offMinute | 7 * 60 e 21 * 60 | A luz do aquário ou das plantas fica acesa das 07:00 às 21:00 |
| scheduleEnabled (programação ativa) | false (desativado) | Programação diária desativada; só o painel, o botão e a contagem regressiva funcionam |
| Fuso horário do configTzTime | "CET-1CEST,M3.5.0,M10.5.0/3" | Horário da Europa Central, incluindo as mudanças do horário de verão |
Limite de carga: o que você pode ligar na tomada?
Você encontra a corrente de um aparelho com a fórmula I = P / V: em 230 V, um aparelho de 1000 W consome 1000 / 230 ≈ 4,3 A. O “10A 250VAC” impresso no relé não significa que o módulo aguenta 10 A continuamente; as trilhas da placa, os bornes com parafuso e o próprio relé dos módulos baratos esquentam com essa corrente. Além disso, aparelhos com motor ou compressor puxam várias vezes a corrente de funcionamento na partida, e os contatos fazem arco a cada chaveamento. Como limite prático seguro, mantenha a carga contínua abaixo de 2–3 A (cerca de 500–700 W). Para os detalhes do cálculo de potência, veja Cálculo de potência elétrica.
| Aparelho | Potência típica | Corrente (230 V) | Para esta tomada |
|---|---|---|---|
| Lâmpada LED | 9–12 W | 0,04–0,05 A | Adequado |
| Roteador / modem | 10–15 W | 0,04–0,07 A | Adequado (ideal para reiniciar remotamente) |
| Carregador de celular e notebook | 20–65 W | 0,09–0,28 A | Adequado |
| Ventilador de mesa | 40–60 W | 0,17–0,26 A | Adequado (carga indutiva, o contato desgasta mais rápido) |
| Aquecedor de aquário | 100–200 W | 0,43–0,87 A | Adequado |
| Cafeteira | 1000–1500 W | 4,3–6,5 A | Não recomendado |
| Chaleira elétrica, ferro de passar, aquecedor elétrico | 2000–2400 W | 8,7–10,4 A | De jeito nenhum |
Caixa e segurança na rede elétrica
- Chaveie a fase, não o neutro: o relé sempre vai na fase (L). Se você chavear o neutro, ainda haverá fase dentro do aparelho mesmo com a tomada desligada, e o risco de choque continua.
- Terra sem interrupção: o terminal de terra da tomada com aterramento vai direto ao condutor de terra da entrada; ele não passa pelo relé nem pela placa do circuito.
- Separe os compartimentos: os fios de 230 V, os contatos do relé e a entrada do HLK-PM01 ficam de um lado da caixa; o ESP32 e os fios de 5 V, do outro. Deixe pelo menos 6 mm de distância entre as duas áreas e, se necessário, coloque uma divisória de plástico.
- Fio e bornes adequados: no lado da rede, use fio flexível de pelo menos 1,5 mm² com terminais tubulares nas pontas e bornes firmes. Jumpers e protoboard jamais podem ficar no lado da rede.
- Fusíveis: coloque na linha da carga um fusível menor que o limite do relé (por exemplo, 5 A) e, na entrada do HLK-PM01, um fusível separado de valor baixo.
- Caixa: escolha uma caixa de projeto de plástico antichama (UL94 V-0); se usar caixa metálica, ela precisa ser aterrada. Prenda o cabo de entrada com um prensa-cabo ou abraçadeira para que ele não se solte dos bornes se for puxado.
- Atualização do programa: não conecte o cabo USB nem abra a tampa com a caixa ligada à rede. Para carregar o código sem fio, você pode adicionar o método de atualização OTA do ESP32.
- Primeira energização: antes de ligar à rede pela primeira vez, verifique as ligações contra curto-circuito com um multímetro; faça o primeiro teste em um circuito protegido por dispositivo DR (diferencial residual), com uma pequena lâmpada LED.
Ideias de projetos e melhorias
- Integre à automação residencial: adicione a tomada aos seus outros dispositivos inteligentes e cenários de automação com MQTT e Home Assistant.
- Controle de fora de casa: adicione um bot do Telegram para ligar e desligar a tomada de qualquer lugar sem abrir portas no modem.
- Tire a senha do código: com o WiFiManager, informe os dados do Wi-Fi pelo celular na primeira inicialização; você não precisa carregar o código de novo quando a rede mudar.
- Tomada com termostato: adicione um DHT11 ou um DS18B20 e acione um aquecedor ou ventilador conforme a temperatura.
- Chaveamento silencioso: se você não quer o clique nem o desgaste dos contatos, use um relé de estado sólido (SSR) para cargas resistivas.
- Tomada acionada por movimento: monte com um sensor PIR um sistema que acende a luz quando você entra no cômodo e apaga depois de 5 minutos sem movimento.
- Versão com Pico W: se quiser testar a mesma ideia com MicroPython, comece pelo artigo servidor web no Pico W.
Erros comuns e como resolvê-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| O relé nunca desarma | Um módulo ativo em LOW alimentado com 5 V não desliga totalmente com HIGH de 3,3 V | Separe o JD-VCC ou use um módulo acionado com 3,3 V |
| O ESP32 reinicia quando o relé aciona | Queda de tensão (brownout) ou interferência do arco nos contatos | Adicione capacitores de 470 µF e 100 nF na linha de 5V e encurte os fios |
| O painel não abre | O celular está em outra rede, o IP mudou ou o ESP32 não conseguiu se conectar ao Wi-Fi | Confira o IP no Monitor Serial e atribua um IP fixo |
| A hora aparece como “--:--” | Não foi possível acessar o servidor NTP | Verifique a conexão com a internet e o DNS e adicione um segundo servidor |
| A programação roda com 3 horas de diferença | Nenhum fuso horário definido, está usando UTC | Escreva a string de fuso horário correta com configTzTime |
| O relé dá um pulso rápido na inicialização | Foi escolhido um pino de inicialização como GPIO 0, 2, 12 ou 15, ou o módulo é ativo em HIGH | Use um pino seguro como o GPIO 26 e confira o tipo do módulo |
| O relé e os bornes esquentam | A carga é maior do que o módulo aguenta | Reduza a carga para menos de 2–3 A; para cargas grandes, use um contator |
A tomada inteligente com ESP32 é um projeto muito didático, porque reúne Wi-Fi, servidor web, controle de tempo e eletrônica de potência em uma só montagem. Se você avançar na ordem certa e com paciência, terá um aparelho parecido com os produtos comerciais, mas totalmente sob o seu controle. No app BlueGrays, você pode aprimorar ainda mais esta tomada estudando passo a passo projetos de servidor web com ESP32, relógio NTP, mDNS e iluminação com relé, com esquemas do circuito e códigos prontos.
Perguntas frequentes
É seguro fazer uma tomada inteligente com ESP32?
O lado de baixa tensão (ESP32, bobina do relé e código) é totalmente seguro; o risco real está no lado de 230 V. As regras básicas são chavear a fase com o relé, deixar o terra sem interrupção, usar fusíveis e colocar tudo em uma caixa fechada antichama. Se você não tem experiência, teste primeiro com uma carga de 12 V e peça a alguém que entenda para conferir a ligação à rede.
O HLK-PM01 consegue alimentar o ESP32 e o relé ao mesmo tempo?
Sim, para um circuito com um só relé ele basta. O HLK-PM01 fornece 600 mA em 5 V; o ESP32 consome em média 80–120 mA e cerca de 300 mA nos picos do Wi-Fi, e a bobina do relé consome 70–90 mA. Adicione um capacitor de 470 µF na linha de 5 V para suavizar as variações de tensão; se for usar vários relés, escolha um módulo de 5 W como o HLK-5M05.
O ESP32 consegue acionar um módulo relé de 5 V?
A maioria dos módulos com transistor de acionamento funciona sem problemas com a saída de 3,3 V do ESP32; a bobina é alimentada com 5 V e o pino do ESP32 fornece só alguns miliampères. Já nos módulos com optoacoplador e ativos em LOW, o nível HIGH de 3,3 V pode não desarmar o relé totalmente. Nesse caso, retire o jumper JD-VCC e ligue o VCC ao 3V3 e o JD-VCC a 5 V.
O que a tomada inteligente faz quando a energia cai e volta?
Por segurança, o código deste artigo inicia o relé desligado em toda inicialização. Se você quer que ela lembre o último estado, pode gravar o estado na flash com a biblioteca Preferences e restaurá-lo em setup(). A hora NTP é obtida de novo em poucos segundos quando a internet volta, e a programação diária continua de onde parou.
Posso controlar a tomada inteligente pela internet, fora de casa?
O painel web deste código só pode ser acessado pela rede local da sua casa. Para controle remoto, usar um serviço como bot do Telegram, MQTT, Blynk ou Firebase é mais fácil e mais seguro do que abrir uma porta no modem. Como é o próprio ESP32 que se conecta a esses serviços, você não abre uma porta de fora para a rede da sua casa.
Quantos watts posso ligar em uma tomada inteligente com ESP32?
Mesmo que os módulos relé de hobby digam 10 A, o seguro é manter a carga contínua abaixo de 2–3 A, ou seja, cerca de 500–700 W em 230 V. Luminárias, carregadores, roteadores, ventiladores e equipamentos de aquário são adequados. Aparelhos de alta potência, como chaleira elétrica, ferro de passar, aquecedor elétrico e ar-condicionado, não devem ser ligados neste projeto.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

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.

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.

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.

Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
Neste projeto, dois botões conectados ao ESP32 (GPIO 5 aumenta, GPIO 4 diminui) alteram um contador. O valor é atualizado instantaneamente no LCD I2C 16x2 e, com o suporte a WebSocket do ESPAsyncWebServer, em todos os navegadores conectados, sem recarregar a página. Em vez de consultas periódicas por HTTP, usamos uma única conexão persistente, e o ESP32 envia o novo valor a todos com ws.textAll().

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

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.

Acender uma lâmpada de 220V com controle remoto
Ligue e desligue uma lâmpada de casa com o controle da TV, sem sair do sofá. O Arduino lê o sinal de luz invisível do controle; o botão de ligar aciona o relé e acende a lâmpada, e o botão de…
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

