Guias · 12 min de leitura

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.

Placa de desenvolvimento ESP32
Placa ESP32 DevKit: Wi-Fi, servidor web e relógio NTP em um só chip; o cérebro da tomada inteligente.

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çaFunçãoValor importante
ESP32 DevKitWi-Fi, painel web, timer e relógio NTPLógica de 3,3 V, pico de 250–350 mA ao transmitir Wi-Fi
Módulo relé de 5 V com 1 canalAbre e fecha a fase da tomadaContato: 10 A 250 V AC (SRD-05VDC-SL-C)
HLK-PM01Converte 230 V AC em 5 V DC5 V, 600 mA (3 W), isolado
Fusível e varistorProtegem a entrada do HLK-PM01 contra curto-circuito e sobretensãoPor exemplo, fusível retardado de 0,5 A e varistor de 275 V AC (10D431K)
Botão de pressãoLiga e desliga manualmente pela caixaGPIO 27, pull-up interno
Caixa de projeto e tomada com aterramentoIsolação e proteção contra toquePlástico antichama UL94 V-0
Relé
Relé: uma chave eletromecânica que chaveia uma carga de 230 V com uma pequena corrente na bobina. A versão em módulo já vem com o transistor de acionamento e o diodo de proteção.

Consumo: o HLK-PM01 dá conta?

ConsumidorCorrente típica (linha de 5 V)Observação
ESP32 (Wi-Fi conectado, ocioso)80–120 mAO 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 mASó enquanto o relé está acionado
LEDs de status5–10 mALEDs do módulo e da placa
Total (pior caso)Cerca de 450 mALimite 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

TerminalLiga emObservação
Entradas AC do HLK-PM01L e N da rede (depois do fusível e do varistor)No compartimento de alta tensão da caixa
HLK-PM01 +Vo5V (VIN) do ESP32 e VCC do módulo reléDesconecte a rede ao carregar o programa
HLK-PM01 -VoGND do ESP32 e GND do módulo reléGND comum
IN do reléGPIO 26 do ESP32Pino seguro que não gera sinal na inicialização
BotãoGPIO 27 e GNDINPUT_PULLUP, sem resistor externo
LED de statusGPIO 2Integrado na maioria das placas DevKit
COM do reléFase da rede (L), depois do fusívelSó a fase é chaveada
NO do reléTerminal de fase da tomadaNormalmente aberto: a tomada fica sem energia quando o relé desarma
Neutro (N) e terra (PE)Direto para os terminais N e terra da tomadaNão passam pelo relé, seguem sem interrupção
Em módulos relé alimentados com 5 V, com optoacoplador e ativos em LOW, a saída HIGH de 3,3 V do ESP32 pode não apagar totalmente o LED do optoacoplador; aí o relé fica sempre acionado ou nunca desarma. A solução é retirar o jumper JD-VCC do módulo e ligar o pino VCC ao pino 3V3 do ESP32 e o pino JD-VCC a 5 V, ou usar um módulo com transistor que possa ser acionado com 3,3 V.

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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ódigoO 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
Depois de carregar o código, você verá no Monitor Serial o endereço IP que o ESP32 recebeu (por exemplo, 192.168.1.47); digite esse endereço no navegador com o celular na mesma rede Wi-Fi. Se você atribuir um IP fixo a esse dispositivo (reserva de DHCP) na interface do seu modem, o endereço nunca muda. Algumas versões do Android não conseguem resolver endereços .local; nesse caso, use diretamente o endereço 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.

AjusteValor de exemploResultado
onMinute (horário de ligar)18 * 60 + 30Liga todo dia às 18:30
offMinute (horário de desligar)23 * 60Desliga todo dia às 23:00
onMinute e offMinute7 * 60 e 21 * 60A 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.

AparelhoPotência típicaCorrente (230 V)Para esta tomada
Lâmpada LED9–12 W0,04–0,05 AAdequado
Roteador / modem10–15 W0,04–0,07 AAdequado (ideal para reiniciar remotamente)
Carregador de celular e notebook20–65 W0,09–0,28 AAdequado
Ventilador de mesa40–60 W0,17–0,26 AAdequado (carga indutiva, o contato desgasta mais rápido)
Aquecedor de aquário100–200 W0,43–0,87 AAdequado
Cafeteira1000–1500 W4,3–6,5 ANão recomendado
Chaleira elétrica, ferro de passar, aquecedor elétrico2000–2400 W8,7–10,4 ADe 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.
A tensão da rede de 230 V é letal e um curto-circuito pode causar incêndio. Mantenha sempre o plugue fora da tomada enquanto faz as ligações e nunca energize o aparelho antes de fechar a tampa. Se você tem menos de 18 anos ou não tem experiência com instalações elétricas, faça você mesmo a parte de baixa tensão do projeto e peça a um eletricista ou a um adulto experiente que confira a ligação à rede. Em projetos escolares e de feira de ciências, fazer a demonstração com uma fita LED de 12 V é suficiente e seguro.

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

SintomaCausa provávelSolução
O relé nunca desarmaUm módulo ativo em LOW alimentado com 5 V não desliga totalmente com HIGH de 3,3 VSepare o JD-VCC ou use um módulo acionado com 3,3 V
O ESP32 reinicia quando o relé acionaQueda de tensão (brownout) ou interferência do arco nos contatosAdicione capacitores de 470 µF e 100 nF na linha de 5V e encurte os fios
O painel não abreO celular está em outra rede, o IP mudou ou o ESP32 não conseguiu se conectar ao Wi-FiConfira o IP no Monitor Serial e atribua um IP fixo
A hora aparece como “--:--”Não foi possível acessar o servidor NTPVerifique a conexão com a internet e o DNS e adicione um segundo servidor
A programação roda com 3 horas de diferençaNenhum fuso horário definido, está usando UTCEscreva a string de fuso horário correta com configTzTime
O relé dá um pulso rápido na inicializaçãoFoi escolhido um pino de inicialização como GPIO 0, 2, 12 ou 15, ou o módulo é ativo em HIGHUse um pino seguro como o GPIO 26 e confira o tipo do módulo
O relé e os bornes esquentamA carga é maior do que o módulo aguentaReduza a carga para menos de 2–3 A; para cargas grandes, use um contator
Para uma placa que não se conecta ao Wi-Fi, veja ESP32 não conecta ao Wi-Fi, e para uma placa que reinicia no instante em que o relé aciona, veja Brownout e Guru Meditation no ESP32. Se você quer que a tomada lembre o último estado depois de uma queda de energia, pode salvar relayOn na flash com a biblioteca Preferences e restaurá-lo na inicialização; mas, para cargas como aquecedores, a escolha segura é sempre “começar desligado”.

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.

Ver todos os projetos
LED piscando com ESP32
ES-1Iniciante

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.

4.7(37)
108
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
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
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
Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
ES-28Avançado
Premium

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

4.5(14)
23
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
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
Acender uma lâmpada de 220V com controle remoto
AR-21Avançado
Premium

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…

4.4(23)
31