Enchufe inteligente ESP32: relé, panel web y temporizador NTP
Crea un enchufe inteligente con ESP32: relé y HLK-PM01, panel web para encender y apagar, temporizador con hora NTP, límite de carga y seguridad a 230 V.
Un enchufe inteligente con ESP32 convierte un enchufe normal en un dispositivo que puedes encender y apagar por Wi-Fi desde el móvil o el ordenador, e incluso hacer que funcione solo a ciertas horas. La idea es simple: el ESP32 se conecta a tu red doméstica y publica un pequeño panel web; cuando pulsas "Encender", el ESP32 activa un relé y este cierra la línea de fase del enchufe, dando corriente al aparato conectado. Para alimentar todo desde la red eléctrica, un diminuto módulo AC-DC llamado HLK-PM01 convierte los 230 V en 5 V, así que no necesitas un adaptador aparte dentro de la caja.
En esta guía verás paso a paso cómo elegir las piezas, calcular el presupuesto de potencia, hacer el cableado, escribir el código con panel web y añadir un temporizador de cuenta atrás y un horario diario con hora NTP. Eso sí, este proyecto trabaja con los 230 V de la red y no perdona errores. Por eso hay una regla principal en todo el artículo: pruébalo todo primero con baja tensión; cuando el código y el cableado funcionen a la perfección, pasa a la red respetando las normas de caja y aislamiento. Si no tienes experiencia con instalaciones eléctricas, haz el último paso siempre bajo la supervisión de alguien que sepa.

¿Qué es un enchufe inteligente con ESP32 y cómo funciona?
Los enchufes inteligentes comerciales también tienen los mismos tres bloques: un microcontrolador Wi-Fi, un elemento de conmutación (normalmente un relé) y una pequeña fuente que genera baja tensión a partir de la red. En nuestra versión, el ESP32 gestiona la conexión Wi-Fi, el servidor web y el reloj. El relé conmuta la carga de 230 V manteniéndola aislada eléctricamente de la débil señal de 3,3 V del ESP32; cuando se alimenta la bobina, el contacto interno se cierra y lo notas por un "clic" audible. El HLK-PM01 es una fuente conmutada encapsulada, con aislamiento entre entrada y salida, que da 5 V DC y como máximo 3 W (600 mA) desde una entrada de 100–240 V AC. Para conocer su estructura interna y su circuito de protección, consulta el artículo convertidor AC-DC HLK-PM01.
| Pieza | Función | Valor importante |
|---|---|---|
| ESP32 DevKit | Wi-Fi, panel web, temporizador y reloj NTP | Lógica de 3,3 V, pico de 250–350 mA al transmitir por Wi-Fi |
| Módulo relé de 5 V de 1 canal | Abre y cierra la línea de fase del enchufe | Contacto: 10 A 250 V AC (SRD-05VDC-SL-C) |
| HLK-PM01 | Convierte 230 V AC en 5 V DC | 5 V, 600 mA (3 W), aislado |
| Fusible y varistor | Protegen la entrada del HLK-PM01 contra cortocircuitos y sobretensiones | Por ejemplo, fusible retardado de 0,5 A y varistor de 275 V AC (10D431K) |
| Pulsador | Encendido y apagado manual desde la caja | GPIO 27, pull-up interno |
| Caja de proyecto y enchufe con toma de tierra | Aislamiento y seguridad al tacto | Plástico ignífugo UL94 V-0 |

Presupuesto de potencia: ¿basta el HLK-PM01?
| Consumidor | Corriente típica (línea de 5 V) | Nota |
|---|---|---|
| ESP32 (Wi-Fi conectado, en reposo) | 80–120 mA | El regulador de la placa baja los 5 V a 3,3 V |
| ESP32 (pico de transmisión Wi-Fi) | 250–350 mA (breve) | Hay que suavizarlo con un condensador |
| Bobina del relé (5 V) | 70–90 mA | Solo mientras el relé está activado |
| LED de estado | 5–10 mA | LED del módulo y de la placa |
| Total (peor caso) | Unos 450 mA | El límite del HLK-PM01 es 600 mA |
Como ves en la tabla, un enchufe inteligente con un solo relé cabe en los 600 mA del HLK-PM01, pero el margen no es muy amplio. Por eso conviene colocar un condensador electrolítico de al menos 470 µF cerca del pin 5V (VIN) del ESP32 y, a su lado, uno cerámico de 100 nF: así evitas que la tensión caiga y la placa se reinicie en los picos de corriente del Wi-Fi o cuando se activa el relé. Si usas un relé de cuatro canales y los activas todos a la vez, solo las bobinas superan los 300 mA; en ese caso debes elegir un módulo más potente, como el HLK-5M05 de 5 W. Puedes comprobar rápidamente los cálculos de corriente y potencia con la calculadora de la ley de Ohm.
Esquema de conexión: ESP32, relé y HLK-PM01
| Terminal | Se conecta a | Nota |
|---|---|---|
| Entradas AC del HLK-PM01 | L y N de la red (después del fusible y el varistor) | En el compartimento de alta tensión de la caja |
| +Vo del HLK-PM01 | 5V (VIN) del ESP32 y VCC del módulo relé | Desconecta la red al cargar el programa |
| -Vo del HLK-PM01 | GND del ESP32 y GND del módulo relé | Masa común |
| IN del relé | GPIO 26 del ESP32 | Pin seguro que no genera señal al arrancar |
| Pulsador | GPIO 27 y GND | INPUT_PULLUP, no hace falta resistencia externa |
| LED de estado | GPIO 2 | Integrado en la mayoría de placas DevKit |
| COM del relé | Fase de la red (L), después del fusible | Solo se corta la fase |
| NO del relé | Terminal de fase del enchufe | Normalmente abierto: si el relé se suelta, el enchufe queda sin tensión |
| Neutro (N) y tierra (PE) | Directamente a los terminales N y tierra del enchufe | No pasan por el relé, siguen sin interrupción |
Hay un motivo para elegir el GPIO 26 para el relé: los GPIO 0, 2, 12 y 15 son pines de arranque (strapping) y afectan a cómo inicia la placa; los GPIO 1 y 3 están reservados al puerto serie, del 6 al 11 a la memoria flash interna, y los GPIO 5 y 14 generan señales breves al arrancar. El GPIO 26 no hace nada de eso. El GPIO 2 solo se usa como salida para el LED de la placa, así que no da problemas. También es importante usar el terminal NO (normalmente abierto) del relé: cuando el ESP32 está apagado, se reinicia o falla, el relé se suelta y el enchufe queda sin tensión. Si usas el terminal NC ocurre lo contrario y, en caso de fallo, el aparato queda funcionando sin parar.
Pruébalo primero con baja tensión
- Alimenta el ESP32 solo con el cable USB; en esta fase no conectes el HLK-PM01. Conecta VCC del módulo relé al pin 5V (VIN) del ESP32, GND a GND e IN al GPIO 26.
- En lugar de 230 V, conecta una carga de baja tensión a los terminales COM y NO del relé: basta un adaptador de 12 V con una tira LED corta, o un LED alimentado a 5 V con una resistencia de 220 Ω.
- Carga el código de prueba de abajo y abre el Monitor Serie a 115200 baudios; el relé debe hacer clic cada 2 segundos y el LED parpadear.
- Si el relé funciona al revés (la pantalla dice "ACIK" y la carga está apagada), cambia el valor de RELAY_ACTIVE_LOW en el código.
- Después carga el código con panel web, prueba el encendido y apagado desde el móvil y el temporizador; reinicia el ESP32 y comprueba que el relé arranca apagado y que la placa no se bloquea cuando se pierde el Wi-Fi.
- Deja el montaje funcionando un día entero con baja tensión y comprueba que el horario NTP enciende y apaga a la hora correcta; solo entonces pasa a la instalación en la red.
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}La función relaySet() traduce las órdenes "encender" y "apagar" a la lógica de activación del módulo. La mayoría de los módulos relé del mercado se activan en LOW: el relé se activa cuando el terminal IN se lleva a GND. En lugar de pensar en esta lógica invertida en todo el código, gestionarla con una sola constante (RELAY_ACTIVE_LOW) evita errores. Hay otra ventaja: cuando el ESP32 arranca o se reinicia, los pines están en modo entrada, y un módulo activo en LOW con IN al aire no se activa por sí solo en ese momento. Para ver la estructura interna del relé y su circuito excitador, echa un vistazo a ¿Qué es un módulo relé?.
Código del enchufe inteligente con panel web
Si la prueba ha ido bien, ya puedes pasar al código principal. La biblioteca WebServer que viene con el núcleo Arduino del ESP32 no necesita instalación adicional y funciona igual en las versiones 2.x y 3.x del núcleo. El código ofrece un panel de control en la página principal, comandos en las direcciones /on, /off, /toggle y /timer?min=30, y el estado del enchufe en JSON en /state. El panel consulta /state cada 2 segundos, así que también ves en el móvil los cambios hechos con el pulsador de la caja o por el horario. No olvides cambiar el nombre y la contraseña del Wi-Fi al principio del código según tu red; el ESP32 solo se conecta a redes de 2,4 GHz. Si quieres actualizaciones instantáneas, consulta Servidor web ESP32 y 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}| Fragmento de código | Qué hace |
|---|---|
| relaySet(bool on) | Actualiza a la vez el relé, el LED de estado y la variable relayOn |
| server.on("/timer", ...) | Con un parámetro como ?min=30 enciende el enchufe y lo apaga al acabar el tiempo (1–720 minutos) |
| minutesLeft() | Calcula el tiempo restante del temporizador en minutos, redondeando hacia arriba |
| (long)(millis() - offAtMs) >= 0 | Comparación de tiempo resistente al desbordamiento de millis() (unos 49,7 días) |
| configTzTime("<+03>-3", ...) | Obtiene la hora de los servidores NTP y la convierte a la hora de Turquía (UTC+3) |
| lastCheckedMinute | Hace que el horario se compruebe una sola vez por minuto; no pisa una orden que hayas dado a mano |
| MDNS.begin("akillipriz") | Te permite acceder al panel con http://akillipriz.local en lugar de la IP |
Funcionamiento automático con temporizador y NTP
El ESP32 no tiene un reloj con batería; al encenderse no sabe qué hora es. La llamada a configTzTime() inicia en segundo plano el cliente SNTP, obtiene la hora UTC de servidores como pool.ntp.org y la convierte en hora local según la cadena de zona horaria que le des. Una vez obtenida la hora, el ESP32 sigue contando con su propio temporizador y, por defecto, se resincroniza cada hora. Como Turquía no aplica horario de verano e invierno desde 2016, basta con la cadena "<+03>-3"; en formato POSIX el signo se escribe al revés, por eso UTC+3 aparece como -3. Para más detalles, consulta Hora de internet con NTP en el ESP32.
En el código hay dos tipos de funcionamiento automático. El primero es el temporizador de cuenta atrás: el botón "30 dk" del panel enciende el enchufe y lo apaga al acabar el tiempo; es ideal para aparatos que no quieres dejar encendidos por descuido, como un cargador, un aireador de acuario o un ventilador. El segundo es el horario diario: el enchufe se enciende cada día a la hora onMinute y se apaga a la hora offMinute. Como el horario solo actúa en el instante en que cambia el minuto y exactamente en ese minuto, una lámpara que apagaste a mano a las 20:00 seguirá apagada hasta la siguiente hora de encendido. Por la misma razón, también funcionan sin problemas horarios que pasan de medianoche, como encender a las 22:00 y apagar a las 06:00.
| Ajuste | Valor de ejemplo | Resultado |
|---|---|---|
| onMinute | 18 * 60 + 30 | Enciende cada día a las 18:30 |
| offMinute | 23 * 60 | Apaga cada día a las 23:00 |
| onMinute y offMinute | 7 * 60 y 21 * 60 | La lámpara del acuario o de las plantas se enciende de 07:00 a 21:00 |
| scheduleEnabled | false | Horario diario desactivado; solo funcionan el panel, el pulsador y la cuenta atrás |
| Zona horaria de configTzTime | "CET-1CEST,M3.5.0,M10.5.0/3" | Hora de Europa Central, con cambio de horario de verano |
Límite de carga: ¿qué puedes conectar al enchufe?
La corriente que consume un aparato se calcula con la fórmula I = P / V: a 230 V, un aparato de 1000 W consume 1000 / 230 ≈ 4,3 A. Que el relé ponga "10A 250VAC" no significa que el módulo pueda llevar 10 A de forma continua; en los módulos baratos, las pistas del circuito impreso, los bornes de tornillo y el propio relé se calientan con esa corriente. Además, los aparatos con motor y compresor consumen varias veces su corriente de trabajo al arrancar, y los contactos hacen arco en cada conmutación. Como límite práctico seguro, mantén la carga continua por debajo de 2–3 A (unos 500–700 W). Los detalles del cálculo de potencia están en Cálculo de potencia eléctrica.
| Aparato | Potencia típica | Corriente (230 V) | Para este enchufe |
|---|---|---|---|
| Bombilla LED | 9–12 W | 0,04–0,05 A | Apto |
| Router / módem | 10–15 W | 0,04–0,07 A | Apto (ideal para reiniciar a distancia) |
| Cargador de móvil y portátil | 20–65 W | 0,09–0,28 A | Apto |
| Ventilador de mesa | 40–60 W | 0,17–0,26 A | Apto (carga inductiva, los contactos se desgastan antes) |
| Calentador de acuario | 100–200 W | 0,43–0,87 A | Apto |
| Cafetera | 1000–1500 W | 4,3–6,5 A | No recomendado |
| Hervidor, plancha, estufa eléctrica | 2000–2400 W | 8,7–10,4 A | Rotundamente no |
Caja y seguridad en la red eléctrica
- Se corta la fase, no el neutro: El relé se conecta siempre a la línea de fase (L). Si cortas el neutro, hay fase dentro del aparato incluso con el enchufe apagado y el peligro de contacto persiste.
- Tierra sin interrumpir: El terminal de tierra del enchufe con toma de tierra se conecta directamente al conductor de tierra de la entrada; no pasa por el relé ni por la placa.
- Separa los compartimentos: Los cables de 230 V, los contactos del relé y la entrada del HLK-PM01 van en un lado de la caja; el ESP32 y los cables de 5 V, en el otro. Deja al menos 6 mm de separación entre ambas zonas y, si hace falta, pon una división de plástico.
- Cable y bornes adecuados: En el lado de red usa cable multifilar de al menos 1,5 mm², con terminales de punta y bornes firmes. Los cables jumper y la protoboard no deben estar nunca en el lado de red.
- Fusible: Pon en la línea de carga un fusible menor que el límite del relé (por ejemplo, 5 A) y otro fusible aparte de poco valor en la entrada del HLK-PM01.
- Caja: Elige una caja de proyecto de plástico ignífugo (UL94 V-0); si usas una metálica, conéctala sí o sí a tierra. Sujeta el cable de entrada con un prensaestopas o una abrazadera para que, si tiran de él, no se suelte de los bornes.
- Actualización del programa: Con la caja conectada a la red, no enchufes el cable USB ni abras la tapa. Para cargar el código sin cables puedes añadir la actualización OTA del ESP32.
- Primera conexión: Antes de conectar a la red por primera vez, comprueba con el multímetro que no hay cortocircuitos en los cables; haz la primera prueba en una línea protegida por un diferencial y con una pequeña bombilla LED.
Ideas de proyecto y mejoras
- Intégralo en tu domótica: Añade el enchufe a tus otros dispositivos inteligentes y escenas de automatización con MQTT y Home Assistant.
- Control desde fuera de casa: Con un bot de Telegram puedes encender y apagar el enchufe desde cualquier lugar sin abrir puertos en el router.
- Saca la contraseña del código: Con WiFiManager introduces los datos del Wi-Fi desde el móvil en el primer arranque; si cambias de red, no tienes que volver a cargar el código.
- Enchufe con termostato: Añade un DHT11 o un DS18B20 y haz funcionar la estufa o el ventilador según la temperatura.
- Conmutación silenciosa: Si no quieres el clic ni el desgaste de los contactos, usa un relé de estado sólido (SSR) con cargas resistivas.
- Enchufe con detección de movimiento: Con un sensor PIR monta un sistema que enciende la lámpara al entrar en la habitación y la apaga si no hay movimiento durante 5 minutos.
- Versión con Pico W: Si quieres probar la misma idea con MicroPython, empieza por el artículo del servidor web con Pico W.
Errores frecuentes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| El relé nunca se suelta | Módulo activo en LOW alimentado a 5 V que no se desactiva del todo con HIGH de 3,3 V | Separa JD-VCC o usa un módulo activado con 3,3 V |
| El ESP32 se reinicia al activarse el relé | Caída de tensión (brownout) o interferencia generada por el arco de los contactos | Añade condensadores de 470 µF y 100 nF a la línea de 5V y acorta los cables |
| El panel no abre | El móvil está en otra red, la IP ha cambiado o el ESP32 no se ha conectado al Wi-Fi | Comprueba la IP en el Monitor Serie y asigna una IP fija |
| La hora aparece como "--:--" | No se ha podido llegar al servidor NTP | Revisa la conexión a internet y el DNS, y añade un segundo servidor |
| El programa funciona con 3 horas de desfase | No se ha indicado la zona horaria y se usa UTC | Escribe la cadena de zona horaria correcta con configTzTime |
| El relé se activa un instante al arrancar | Se ha elegido un pin de arranque como GPIO 0, 2, 12 o 15, o el módulo se activa en HIGH | Usa un pin seguro como el GPIO 26 y comprueba el tipo de módulo |
| El relé y los bornes se calientan | La carga es mayor de lo que soporta el módulo | Baja la carga a menos de 2–3 A; para cargas grandes usa un contactor |
El enchufe inteligente con ESP32 es un proyecto muy didáctico porque reúne Wi-Fi, servidor web, gestión del tiempo y electrónica de potencia en uno solo. Si avanzas en el orden correcto y con paciencia, conseguirás un dispositivo parecido a los productos comerciales, pero totalmente bajo tu control. En la aplicación BlueGrays puedes mejorar aún más este enchufe estudiando paso a paso proyectos de servidor web con ESP32, reloj NTP, mDNS e iluminación con relé, con esquemas de circuito y código listo.
Preguntas frecuentes
¿Es seguro hacer un enchufe inteligente con ESP32?
La parte de baja tensión (ESP32, bobina del relé y código) es totalmente segura; el verdadero riesgo está en el lado de 230 V. Las reglas básicas son cortar la fase con el relé, dejar la tierra sin interrumpir, usar fusible y colocarlo todo en una caja cerrada e ignífuga. Si no tienes experiencia, pruébalo primero con una carga de 12 V y pide a alguien que sepa que revise la conexión a la red.
¿El HLK-PM01 alimenta a la vez el ESP32 y el relé?
Sí, es suficiente para un circuito con un solo relé. El HLK-PM01 da 600 mA a 5 V; el ESP32 consume de media 80–120 mA, unos 300 mA en los picos de Wi-Fi, y la bobina del relé 70–90 mA. Para suavizar las fluctuaciones de tensión, añade un condensador de 470 µF a la línea de 5 V; si vas a usar varios relés, elige un módulo de 5 W como el HLK-5M05.
¿Puede el ESP32 controlar un módulo relé de 5 V?
La mayoría de los módulos con excitador de transistor se activan sin problema con la salida de 3,3 V del ESP32; la bobina se alimenta a 5 V y del pin del ESP32 solo se toman unos pocos miliamperios. En los módulos con optoacoplador y activación en LOW, el nivel HIGH de 3,3 V puede no soltar del todo el relé. En ese caso, quita el jumper JD-VCC, conecta VCC a 3V3 y JD-VCC a 5 V.
¿Qué hace el enchufe inteligente cuando se va y vuelve la luz?
Por seguridad, el código de este artículo arranca el relé apagado en cada inicio. Si quieres que recuerde el último estado, puedes escribirlo en la memoria flash con la biblioteca Preferences y restaurarlo en setup(). La hora NTP se vuelve a obtener en unos segundos cuando vuelve internet y el horario diario continúa donde se había quedado.
¿Puedo controlar el enchufe inteligente por internet desde fuera de casa?
Al panel web de este código solo se puede acceder desde la red local de casa. Para el control desde fuera, en lugar de abrir puertos en el router, es más fácil y más seguro usar un bot de Telegram, MQTT o un servicio como Blynk o Firebase. Como es el propio ESP32 quien se conecta a esos servicios, no abres ninguna puerta a tu red doméstica desde el exterior.
¿Cuántos vatios puedo conectar a un enchufe inteligente con ESP32?
Aunque los módulos relé de aficionado pongan 10 A, lo seguro es mantener la carga continua por debajo de 2–3 A, es decir, unos 500–700 W a 230 V. Lámparas, cargadores, routers, ventiladores y equipos de acuario son aptos. Aparatos de gran potencia como hervidores, planchas, estufas eléctricas y aires acondicionados no deben conectarse a este proyecto.
Proyectos para hacer después de leer esto
Ver todos los proyectos
LED Parpadeante con ESP32
Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

ESP32: hora real desde Internet con NTP
El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

Encender una bombilla de 220 V con mando a distancia
Enciende y apaga una bombilla de verdad de tu casa con un mando a distancia, sin levantarte del sofá.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

