El usar un relé con el ESP32 es una forma excelente de controlar electrodomésticos de corriente alterna (CA) de forma remota. Este tutorial explica cómo controlar un módulo relé con el ESP32. Veremos cómo funciona un módulo relé, cómo conectarlo al ESP32 y cómo construir un servidor web para controlar un relé de forma remota (o tantos relés como quieras).
¿Qué es un relé y por qué es tan útil?
Un relé es un interruptor accionado eléctricamente. Como cualquier otro interruptor, se puede encender o apagar, dejando pasar la corriente o no. La gran ventaja del relé es que puede controlarse con voltajes bajos, como los 3,3 V que proporcionan los GPIO del ESP32, y a la vez nos permite controlar voltajes altos como 12 V, 24 V o la tensión de red (230 V en Europa y 120 V en Estados Unidos).
Esta separación entre el circuito de control (bajo voltaje) y el circuito controlado (alto voltaje) es lo que convierte al relé en la herramienta perfecta para domotizar cualquier electrodoméstico: lámparas, ventiladores, persianas motorizadas, bombas de agua, calefactores, etc.
Módulos relé: de 1 a 16 canales
Existen diferentes módulos relé con distinto número de canales. Puedes encontrar módulos relé de uno, dos, cuatro, ocho e incluso dieciséis canales. El número de canales determina el número de salidas que podremos controlar.
Hay módulos relé cuyo electroimán puede alimentarse a 5 V y otros a 3,3 V. Ambos se pueden usar con el ESP32: puedes usar el pin VIN (que proporciona 5 V) o el pin de 3,3 V.
Además, algunos incluyen optoacoplador integrado, que añade una “capa” extra de protección al aislar ópticamente el ESP32 del circuito del relé. Esta protección es fundamental cuando trabajas con tensión de red, ya que evita que cualquier pico de tensión del lado de alta potencia dañe tu microcontrolador.
Pinout del módulo relé
Para fines de demostración, veamos el pinout de un módulo relé de 2 canales. Usar un módulo relé con un número diferente de canales es similar.
En el lado izquierdo hay dos juegos de tres tomas para conectar voltajes altos, y los pines del lado derecho (bajo voltaje) se conectan a los GPIO del ESP32.
Conexiones de tensión de red
El módulo relé tiene dos conectores, cada uno con tres tomas: común (COM), normalmente cerrado (NC) y normalmente abierto (NO).
COM: conecta la corriente que quieres controlar (tensión de red). NC (Normalmente Cerrado): la configuración normalmente cerrada se usa cuando quieres que el relé esté cerrado por defecto. Los pines NC y COM están conectados, lo que significa que la corriente fluye a menos que envíes una señal desde el ESP32 al módulo relé para abrir el circuito y detener el flujo de corriente. NO (Normalmente Abierto): la configuración normalmente abierta funciona al revés: no hay conexión entre los pines NO y COM, así que el circuito está roto a menos que envíes una señal desde el ESP32 para cerrarlo.
Usa una configuración normalmente cerrada cuando la corriente deba fluir la mayor parte del tiempo y solo quieras detenerla ocasionalmente. Usa una configuración normalmente abierta cuando quieras que la corriente fluya ocasionalmente (por ejemplo, encender una lámpara de vez en cuando).
Pines de control
El lado de bajo voltaje tiene un juego de cuatro pines y un juego de tres pines. El primer juego consiste en VCC y GND para alimentar el módulo, y la entrada 1 (IN1) y entrada 2 (IN2) para controlar los relés inferior y superior, respectivamente.
Si tu módulo relé solo tiene un canal, tendrás solo un pin IN. Si tienes cuatro canales, tendrás cuatro pines IN, y así sucesivamente.
La señal que envías a los pines IN determina si el relé está activo o no. El relé se dispara cuando la entrada baja de aproximadamente 2 V. Esto significa que tendrás los siguientes escenarios:
Configuración Normalmente Cerrada (NC): señal HIGH → la corriente está fluyendo. señal LOW → la corriente no está fluyendo.
Configuración Normalmente Abierta (NO): señal HIGH → la corriente no está fluyendo. señal LOW → la corriente está fluyendo.
Selección de la fuente de alimentación
El segundo juego de pines consiste en GND, VCC y JD-VCC. El pin JD-VCC alimenta el electroimán del relé. Fíjate en que el módulo tiene un puente (jumper) conectando los pines VCC y JD-VCC; el que se muestra aquí es amarillo, pero el tuyo puede ser de otro color.
Con el puente puesto, los pines VCC y JD-VCC están conectados. Eso significa que el electroimán del relé se alimenta directamente desde el pin de alimentación del ESP32, así que el módulo relé y los circuitos del ESP32 no están físicamente aislados entre sí.
Sin el puente, necesitas proporcionar una fuente de alimentación independiente para alimentar el electroimán del relé a través del pin JD-VCC. Esa configuración aísla físicamente los relés del ESP32 gracias al optoacoplador integrado en el módulo, lo que previene daños al ESP32 en caso de picos eléctricos. Esta es la configuración recomendada para proyectos serios que vayan a funcionar de forma continua con cargas de corriente alterna.
Cablear un módulo relé al ESP32
Conecta el módulo relé al ESP32. El diagrama muestra el cableado para un módulo relé de 2 canales; cablear un número diferente de canales es similar.
Advertencia: en este ejemplo estamos tratando con tensión de red. El mal uso puede provocar lesiones graves. Si no estás familiarizado con la tensión de red, pide ayuda a alguien que lo esté. Mientras programas el ESP32 o cableas tu circuito, asegúrate de que todo esté desconectado de la tensión de red. Como alternativa, puedes usar una fuente de alimentación de 12 V para controlar electrodomésticos de 12 V, que es una forma mucho más segura de empezar.
En este ejemplo, estamos controlando una lámpara. Solo queremos encender la lámpara ocasionalmente, así que es mejor usar una configuración normalmente abierta.
Estamos conectando el pin IN1 al GPIO 26; puedes usar cualquier otro GPIO adecuado.
Controlar un módulo relé con el ESP32: sketch básico
El código para controlar un relé con el ESP32 es tan simple como controlar un LED o cualquier otra salida. En este ejemplo, como estamos usando una configuración normalmente abierta, necesitamos enviar una señal LOW para dejar fluir la corriente, y una señal HIGH para detener el flujo de corriente.
El siguiente código encenderá tu lámpara durante 5 segundos y la apagará durante otros 5 segundos:
/*
Rui Santos
Detalles completos del proyecto en https://RandomNerdTutorials.com/esp32-relay-module-ac-web-server/
*/
const int relay = 26;
void setup() {
Serial.begin(115200);
pinMode(relay, OUTPUT);
}
void loop() {
// Configuración Normalmente Abierta: envía señal LOW para dejar fluir la corriente
// (si usas configuración Normalmente Cerrada, envía señal HIGH)
digitalWrite(relay, LOW);
Serial.println("Current Flowing");
delay(5000);
// Configuración Normalmente Abierta: envía señal HIGH para detener el flujo de corriente
// (si usas configuración Normalmente Cerrada, envía señal LOW)
digitalWrite(relay, HIGH);
Serial.println("Current not Flowing");
delay(5000);
}
Cómo funciona el código
Se define el pin al que está conectado el pin IN del relé. En el setup(), se define el relé como salida. En el loop(), se envía una señal LOW para dejar fluir la corriente y encender la lámpara. Si estás usando una configuración normalmente cerrada, envía una señal HIGH para encender la lámpara. Después, espera 5 segundos. Detén el flujo de corriente enviando una señal HIGH al pin del relé. Si estás usando configuración normalmente cerrada, envía una señal LOW para detener el flujo de corriente.
Controlar múltiples relés con un servidor web en el ESP32
En esta sección, hemos creado un ejemplo de servidor web que te permite controlar tantos relés como quieras vía servidor web, ya estén configurados como normalmente abiertos o normalmente cerrados. Solo necesitas cambiar unas pocas líneas de código para definir el número de relés que quieres controlar y la asignación de pines.
Instalar las librerías del servidor web
Construiremos el servidor web usando las siguientes librerías: la libería ESPAsyncWebServer de ESP32Async y la libería AsyncTCP de ESP32Async.
Puedes instalar estas librerías en el Gestor de Librerías de Arduino. Abre el Gestor de Librerías pulsando el icono de la biblioteca en la barra lateral izquierda. Busca ESPAsyncWebServer e instala la librería ESPAsyncWebServer de ESP32Async. Después, instala la librería AsyncTCP. Busca AsyncTCP e instala la librería AsyncTCP de ESP32Async.
Código completo del servidor web con múltiples relés
Después de instalar las librerías necesarias, copia el siguiente código en tu Arduino IDE:
/*
Rui Santos & Sara Santos - Random Nerd Tutorials
Detalles completos del proyecto en https://RandomNerdTutorials.com/esp32-relay-module-ac-web-server/
*/
// Importa las librerías requeridas
#include "WiFi.h"
#include "ESPAsyncWebServer.h"
// Establece a true para definir el relé como Normalmente Abierto (NO)
#define RELAY_NO true
// Establece el número de relés
#define NUM_RELAYS 5
// Asigna cada GPIO a un relé
int relayGPIOs[NUM_RELAYS] = {2, 26, 27, 25, 33};
// Reemplaza con las credenciales de tu red
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
const char* PARAM_INPUT_1 = "relay";
const char* PARAM_INPUT_2 = "state";
// Crea el objeto AsyncWebServer en el puerto 80
AsyncWebServer server(80);
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
html {font-family: Arial; display: inline-block; text-align: center;}
h2 {font-size: 3.0rem;}
p {font-size: 3.0rem;}
body {max-width: 600px; margin:0px auto; padding-bottom: 25px;}
.switch {position: relative; display: inline-block; width: 120px; height: 68px}
.switch input {display: none}
.slider {position: absolute; top: 0; left: 0; right: 0; bottom: 0; background-color: #ccc; border-radius: 34px}
.slider:before {position: absolute; content: ""; height: 52px; width: 52px; left: 8px; bottom: 8px; background-color: #fff; -webkit-transition: .4s; transition: .4s; border-radius: 68px}
input:checked+.slider {background-color: #2196F3}
input:checked+.slider:before {-webkit-transform: translateX(52px); -ms-transform: translateX(52px); transform: translateX(52px)}
</style>
</head>
<body>
<h2>ESP Web Server</h2>
%BUTTONPLACEHOLDER%
<script>function toggleCheckbox(element) {
var xhr = new XMLHttpRequest();
if(element.checked){ xhr.open("GET", "/update?relay="+element.id+"&state=1", true); }
else { xhr.open("GET", "/update?relay="+element.id+"&state=0", true); }
xhr.send();
}</script>
</body>
</html>
)rawliteral";
// Reemplaza el placeholder con la sección de botones en tu página web
String processor(const String& var){
if(var == "BUTTONPLACEHOLDER"){
String buttons ="";
for(int i=1; i<=NUM_RELAYS; i++){
String relayStateValue = relayState(i);
buttons+= "<h4>Relay #" + String(i) + " - GPIO " + relayGPIOs[i-1] + "</h4><label class=\"switch\"><input type=\"checkbox\" onchange=\"toggleCheckbox(this)\" id=\"" + String(i) + "\" "+ relayStateValue +"><span class=\"slider\"></span></label>";
}
return buttons;
}
return String();
}
String relayState(int numRelay){
if(RELAY_NO){
if(digitalRead(relayGPIOs[numRelay-1])){
return "";
}
else {
return "checked";
}
}
else {
if(digitalRead(relayGPIOs[numRelay-1])){
return "checked";
}
else {
return "";
}
}
return "";
}
void setup(){
// Puerto serie para propósitos de depuración
Serial.begin(115200);
// Establece todos los relés a apagado cuando el programa arranca
for(int i=1; i<=NUM_RELAYS; i++){
pinMode(relayGPIOs[i-1], OUTPUT);
if(RELAY_NO){
digitalWrite(relayGPIOs[i-1], HIGH);
}
else{
digitalWrite(relayGPIOs[i-1], LOW);
}
}
// Conecta a Wi-Fi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi..");
}
// Imprime la dirección IP local del ESP32
Serial.println(WiFi.localIP());
// Ruta para la raíz / página web
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
request->send(200, "text/html", index_html, processor);
});
// Envía una petición GET a <ESP_IP>/update?relay=<inputMessage>&state=<inputMessage2>
server.on("/update", HTTP_GET, [] (AsyncWebServerRequest *request) {
String inputMessage;
String inputParam;
String inputMessage2;
String inputParam2;
if (request->hasParam(PARAM_INPUT_1) & request->hasParam(PARAM_INPUT_2)) {
inputMessage = request->getParam(PARAM_INPUT_1)->value();
inputParam = PARAM_INPUT_1;
inputMessage2 = request->getParam(PARAM_INPUT_2)->value();
inputParam2 = PARAM_INPUT_2;
if(RELAY_NO){
Serial.print("NO ");
digitalWrite(relayGPIOs[inputMessage.toInt()-1], !inputMessage2.toInt());
}
else{
Serial.print("NC ");
digitalWrite(relayGPIOs[inputMessage.toInt()-1], inputMessage2.toInt());
}
}
else {
inputMessage = "No message sent";
inputParam = "none";
}
Serial.println(inputMessage + inputMessage2);
request->send(200, "text/plain", "OK");
});
// Inicia el servidor
server.begin();
}
void loop() {
}
Definir la configuración del relé
Modifica la siguiente variable para indicar si estás usando tus relés en configuración normalmente abierta (NO) o normalmente cerrada (NC). Establece la variable RELAY_NO a true para normalmente abierto o a false para normalmente cerrado:
#define RELAY_NO true
Definir el número de relés (canales)
Puedes definir el número de relés que quieres controlar en la variable NUM_RELAYS. Para fines de demostración, lo establecemos a 5:
#define NUM_RELAYS 5
Definir la asignación de pines de los relés
En la siguiente variable de tipo array puedes definir los GPIO del ESP32 que controlarán los relés:
int relayGPIOs[NUM_RELAYS] = {2, 26, 27, 25, 33};
El número de relés establecido en la variable NUM_RELAYS debe coincidir con el número de GPIOs asignados en el array relayGPIOs.
Credenciales de red
Inserta tus credenciales de red en las siguientes variables:
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
Cablear un relé de 8 canales al ESP32
Para fines de demostración, estamos controlando 5 canales de relé. Cablea el ESP32 al módulo relé asegurándote de que cada pin IN del módulo va al GPIO correspondiente definido en el array relayGPIOs, y que VCC y GND están correctamente conectados.
Demostración
Después de hacer los cambios necesarios, sube el código a tu ESP32.
Abre el Monitor Serie a 115200 baudios y pulsa el botón EN del ESP32 para obtener su dirección IP. Después, abre un navegador en tu red local y escribe la dirección IP del ESP32 para obtener acceso al servidor web.
Deberías obtener tantos botones como el número de relés que hayas definido en tu código. Ahora, puedes usar los botones para controlar tus relés de forma remota usando tu smartphone.
Caja de protección para mayor seguridad
Para un proyecto final, asegúrate de colocar tu módulo relé y el ESP32 dentro de una caja de protección para evitar cualquier pin de corriente alterna expuesto. Esta precaución no es opcional cuando trabajas con tensión de red: cualquier contacto accidental con los terminales puede ser potencialmente mortal. Usa siempre una caja aislante, con prensaestopas para los cables, y etiqueta claramente los terminales para evitar confusiones en el futuro.
Conclusión: lo que has aprendido
Usar relés con el ESP32 es una forma excelente de controlar electrodomésticos de corriente alterna de forma remota. Controlar un relé con el ESP32 es tan fácil como controlar cualquier otra salida: solo necesitas enviar señales HIGH y LOW como harías para controlar un LED.
La combinación de ESP32 + relé + servidor web es la base de prácticamente cualquier sistema de domótica casero. Con esta técnica puedes controlar luces, ventiladores, persianas, bombas, calefacción y cualquier otro aparato que funcione con corriente alterna, todo ello desde tu móvil o tu ordenador, en tu red local o desde cualquier parte del mundo si añades acceso remoto.
Recuerda las reglas de oro: usa siempre optoacoplador si es posible, alimenta el relé con fuente independiente si vas a trabajar con cargas grandes, y encierra todo en una caja aislante. Con estas precauciones, el binomio ESP32 + relé es una de las herramientas más potentes y versátiles del mundo maker, capaz de convertir cualquier electrodoméstico antiguo en un dispositivo inteligente controlable por Wi-Fi.
Descubre más desde CIBERED
Suscríbete y recibe las últimas entradas en tu correo electrónico.