Módulo de relé ESP32: control de dispositivos de CA (servidor web)

Si estás buscando una forma sencilla y eficiente de controlar tus dispositivos de corriente alterna, el módulo de relé ESP32 es la solución perfecta. En este artículo, te explicaremos cómo utilizar este módulo con un servidor web para tener el control total de tus dispositivos desde cualquier lugar. ¡No te pierdas esta guía paso a paso para optimizar tu hogar u oficina con tecnología de vanguardia!

Usar un relé con el ESP32 es una excelente manera de controlar remotamente electrodomésticos de CA. Este tutorial explica cómo controlar un módulo de relé con el ESP32. Veremos cómo funciona un módulo de relé, cómo conectar el relé al ESP32 y crearemos un servidor web para controlar remotamente un relé (o tantos relés como desee).

Aprenda a controlar un módulo de relé con la placa ESP8266: Instrucciones del módulo de relé ESP8266 – Ejemplo de control de aire acondicionado + servidor web.

Mira el vídeotutorial

Mire el video tutorial a continuación o continúe leyendo esta página para obtener las instrucciones escritas y todos los recursos.

Introducción a los relés

Un relé es un interruptor operado eléctricamente y, como cualquier otro interruptor, se puede encender o apagar, permitiendo que la corriente fluya o no a través de él. Se puede controlar con voltajes bajos, como los 3.3V que proporcionan los GPIO del ESP32, y nos permite controlar voltajes altos como 12V, 24V o tensión de red (230V en Europa y 120V en USA).

Módulos de relé de 1, 2, 4, 8, 16 canales

Existen diferentes módulos de relés con diferente número de canales. Puedes encontrar módulos de relés de uno, dos, cuatro, ocho e incluso dieciséis canales. El número de canales determina el número de salidas que podemos controlar.

Existen módulos de relé cuyo electroimán se puede alimentar con 5V y 3,3V. Ambos se pueden usar con el ESP32; puede usar el pin VIN (que suministra 5 V) o el pin de 3,3 V.

Algunos también tienen optoacopladores incorporados que brindan una capa adicional de protección y aíslan ópticamente el ESP32 del circuito de relé.

Obtenga un módulo de relé:

• Módulo de relé de 2 canales de 5 V (con optoacoplador)
• Módulo de relé de 1 canal de 5 V (con optoacoplador)
• Módulo de relé de 5 V y 8 canales. (con optoacoplador)
• Módulo de relé de 5 V y 16 canales. (con optoacoplador)
• Módulo de relé de 1 canal de 3,3 V. (con optoacoplador)

Distribución de pines del relé

Para fines de demostración, veamos la distribución de pines de un módulo de relé de 2 canales. Usar un módulo de relé con un número diferente de canales es similar.

En el lado izquierdo hay dos juegos de tres enchufes cada uno para conectar altos voltajes, y los pines del lado derecho (bajo voltaje) están conectados a los GPIO ESP32.

Conexiones de tensión de red

El módulo de relé que se muestra en la foto anterior tiene dos conectores, cada uno con tres enchufes: común (COM), Normalmente cerrado (CAROLINA DEL NORTE) y normalmente abierto (NO).

• COM: Conecte la alimentación que desea controlar (tensión de red).
• NC (normalmente cerrado): La configuración normalmente cerrada se utiliza cuando se desea que el relé esté cerrado de forma predeterminada. Los pines NC y COM están conectados, lo que significa que la corriente fluirá a menos que envíe una señal desde el ESP32 al módulo de relé para abrir el circuito y detener el flujo de corriente.
• NO (Normalmente abierto): La configuración normalmente abierta funciona a la inversa: no hay conexión entre los pines NO y COM, por lo que el circuito está abierto a menos que envíes una señal desde el ESP32 para cerrar el circuito.

Pasadores de control

El lado de bajo voltaje tiene un conjunto de cuatro pines y un conjunto de tres pines. La primera frase consiste en VCC Y Dimensiones para encender el módulo, e ingrese 1 (EN 1) y entrada 2 (EN 2) para controlar el relé inferior o superior.

Si su módulo de relé solo tiene un canal, solo tiene un pin IN. Si tienes cuatro canales, tienes cuatro pines IN y así sucesivamente.

La señal que envía a los pines IN determina si el relé está activo o no. El relé se activa cuando la entrada cae por debajo de aproximadamente 2 V. Esto significa que tiene los siguientes escenarios:

• Configuración normalmente cerrada (NC):
  • Señal ALTA: la corriente fluye
  • Señal BAJA: la corriente está encendida no con fluidez
• Configuración normalmente abierta (NO):
  • Señal ALTA: la corriente está encendida no con fluidez
  • Señal BAJA: la corriente fluye

Debe utilizar una configuración normalmente cerrada si la energía debe fluir la mayor parte del tiempo y solo desea interrumpirla ocasionalmente.

Utilice una configuración normalmente abierta si desea que la energía fluya ocasionalmente (por ejemplo, para encender una lámpara ocasionalmente).

Selección de fuente de alimentación

El segundo conjunto de pines consta de Dimensiones, VCCY JD-VCC Lápices. El JD-VCC El pin suministra energía al electroimán del relé. Tenga en cuenta que el módulo tiene una tapa de puente que conecta los pines VCC y JD-VCC. El que se muestra aquí es amarillo, pero el tuyo puede ser de un color diferente.

Con la tapa puente en el VCC Y JD-VCC Los pines están conectados. Esto significa que el solenoide del relé se alimenta directamente desde el pin de alimentación ESP32, por lo que el módulo de relé y los circuitos ESP32 no están físicamente aislados entre sí.

Sin la tapa del puente, necesitará proporcionar una fuente de alimentación independiente para alimentar el solenoide del relé a través del JD-VCC Código PIN. Esta configuración aísla físicamente los relés del ESP32 con el optoacoplador incorporado del módulo, evitando daños al ESP32 en caso de picos de voltaje.

Cableado de un módulo de relé al ESP32

Conecte el módulo de relé al ESP32 como se muestra en el siguiente diagrama. El diagrama muestra el cableado de un módulo de relé de 2 canales, el cableado de un número diferente de canales es similar.

Advertencia: Este ejemplo trata sobre la tensión de red. El mal uso puede provocar lesiones graves. Si no sabes nada sobre el voltaje de la red eléctrica, pídele ayuda a alguien que sí lo sepa. Al programar el ESP o cablear su circuito, asegúrese de que todo esté desconectado de la tensión de red.

Alternativamente, puede utilizar una fuente de alimentación de 12 V para controlar dispositivos de 12 V.

En este ejemplo controlamos una lámpara. Sólo queremos encender la lámpara de vez en cuando, por lo que es mejor utilizar una configuración normalmente abierta.

Conectamos el pin IN1 a GPIO26Puede utilizar cualquier otro GPIO adecuado. Consulte el Manual de referencia de ESP32 GPIO.

Controlando un módulo de relé con el ESP32 – Arduino Sketch

El código para controlar un relé con el ESP32 es tan simple como controlar un LED u otra salida. Dado que en este ejemplo utilizamos una configuración normalmente abierta, necesitamos enviar una señal BAJA para permitir el flujo de corriente y una señal ALTA para detener el flujo de corriente.

El siguiente código hará que su lámpara se encienda durante 10 segundos y se apague durante otros 10 segundos.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-relay-module-ac-web-server/
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

const int relay = 26;

void setup() {
  Serial.begin(115200);
  pinMode(relay, OUTPUT);
}

void loop() {
  // Normally Open configuration, send LOW signal to let current flow
  // (if you're usong Normally Closed configuration send HIGH signal)
  digitalWrite(relay, LOW);
  Serial.println("Current Flowing");
  delay(5000); 
  
  // Normally Open configuration, send HIGH signal stop current flow
  // (if you're usong Normally Closed configuration send LOW signal)
  digitalWrite(relay, HIGH);
  Serial.println("Current not Flowing");
  delay(5000);
}

Ver código sin formato

Cómo funciona el código

Defina el pin al que está conectado el pin IN del relé.

const int relay = 26;

En el configuración()Defina el relé como salida.

pinMode(relay, OUTPUT);

En el Cinta()Entregar BAJO Señal para dejar fluir la corriente y encender la lámpara.

digitalWrite(relay, LOW);

Si está utilizando una configuración normalmente cerrada, envíe una ALTO Señal para encender la lámpara. Luego espere 5 segundos.

delay(5000);

Detenga el flujo de electricidad enviando un ALTO Señal al pin del relé. Si está utilizando una configuración normalmente cerrada, envíe BAJO Señal para detener el flujo de corriente.

digitalWrite(relay, HIGH);

Controle múltiples relés con el servidor web ESP32

En esta sección, hemos creado un ejemplo de servidor web que le permite controlar cualquier número de relés a través del servidor web, independientemente de si están configurados como normalmente abiertos o normalmente cerrados. Solo necesita cambiar algunas líneas de código para especificar la cantidad de relés a controlar y la asignación de pines.

Para construir este servidor web utilizamos el Biblioteca ESPAsyncWebServer.

Instalación de la biblioteca ESPAsyncWebServer

Siga los siguientes pasos para instalar el ESPAsyncWebServer Biblioteca:

1. Haga clic aquí para descargar la biblioteca ESPAsyncWebServer. Deberías tener una carpeta .zip en tu carpeta de Descargas.
2. Descomprima la carpeta .zip y debería obtener Maestro ESPAsyncWebServer Carpeta
3. Cambie el nombre de su carpeta de Maestro ESPAsyncWebServer A ESPAsyncWebServer
4. mueve eso ESPAsyncWebServer Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE

Alternativamente, puedes hacerlo en tu IDE de Arduino. Bosquejo > incluir biblioteca > Agregar biblioteca .ZIP… y seleccione la biblioteca que acaba de descargar.

Instalación de la biblioteca Async TCP para ESP32

El ESPAsyncWebServer La biblioteca requiere la AsíncronoTCP Obras de biblioteca. Siga los siguientes pasos para instalar esta biblioteca:

1. Haga clic aquí para descargar la biblioteca AsyncTCP. Deberías tener una carpeta .zip en tu carpeta de Descargas.
2. Descomprima la carpeta .zip y debería obtener Maestro asíncrono TCP Carpeta
3. Cambie el nombre de su carpeta de Maestro asíncrono TCP A AsíncronoTCP
4. mueve eso AsíncronoTCP Carpeta a la carpeta de bibliotecas de instalación de Arduino IDE
5. Finalmente, vuelva a abrir su IDE de Arduino

Alternativamente, puedes hacerlo en tu IDE de Arduino. Bosquejo > incluir biblioteca > Agregar biblioteca .ZIP… y seleccione la biblioteca que acaba de descargar.

Después de instalar las bibliotecas necesarias, copie el siguiente código en su IDE de Arduino.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-relay-module-ac-web-server/
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

// Import required libraries
#include "WiFi.h"
#include "ESPAsyncWebServer.h"

// Set to true to define Relay as Normally Open (NO)
#define RELAY_NO    true

// Set number of relays
#define NUM_RELAYS  5

// Assign each GPIO to a relay
int relayGPIOs[NUM_RELAYS] = {2, 26, 27, 25, 33};

// Replace with your network credentials
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";

// Create AsyncWebServer object on port 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";

// Replaces placeholder with button section in your web page
String processor(const String& var){
  //Serial.println(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(){
  // Serial port for debugging purposes
  Serial.begin(115200);

  // Set all relays to off when the program starts - if set to Normally Open (NO), the relay is off when you set the relay to HIGH
  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);
    }
  }
  
  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi..");
  }

  // Print ESP32 Local IP Address
  Serial.println(WiFi.localIP());

  // Route for root / web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html, processor);
  });

  // Send a GET request to <ESP_IP>/update?relay=<inputMessage>&state=<inputMessage2>
  server.on("/update", HTTP_GET, [] (AsyncWebServerRequest *request) {
    String inputMessage;
    String inputParam;
    String inputMessage2;
    String inputParam2;
    // GET input1 value on <ESP_IP>/update?relay=<inputMessage>
    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");
  });
  // Start server
  server.begin();
}
  
void loop() {

}

Ver código sin formato

Definir la configuración del relé

Cambie la siguiente variable para indicar si está utilizando sus relés en una configuración normalmente abierta (NO) o normalmente cerrada (NC). Selecciona el RELÉ_NO variable VERDADERO para sistemas operativos normalmente abiertos configurados en INCORRECTO para abridores.

#define RELAY_NO true

Establezca el número de relés (canales).

Puede configurar el número de relés que desea controlar en el NUM_RELÉS Variable. Para fines de demostración lo configuramos en 5.

#define NUM_RELAYS 5

Definir la asignación de pines de los relés.

En la siguiente variable de matriz puede definir los GPIO ESP32 que controlan los relés:

int relayGPIOs[NUM_RELAYS] = {2, 26, 27, 25, 33};

El número de relés en NUM_RELÉS La variable debe coincidir con el número de GPIO presentes en el GPIO de relé -Formación.

Credenciales de red

Incluya sus credenciales de red en las siguientes variables.

const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Cableado de un relé de 8 canales con ESP32

Para fines de demostración controlamos 5 canales de retransmisión. Conecte el ESP32 al módulo de relé como se muestra en el siguiente diagrama de cableado.

demostración

Después de realizar los cambios necesarios, cargue el código en su ESP32.

Abra el monitor serie con una velocidad de baudios de 115200 y presione el botón ESP32 EN para obtener su dirección IP.

Luego abra un navegador en su red local e ingrese la dirección IP ESP32 para obtener acceso al servidor web.

Deberías obtener algo como lo siguiente, con tantos botones como relés hayas definido en tu código.

Ahora puedes usar los botones para controlar remotamente tus relés desde tu teléfono inteligente.

Vivienda para la seguridad

Para un proyecto final, asegúrese de colocar su módulo de relé y ESP en un gabinete para evitar exponer los pines de CA.

Envolver

Usar relés con el ESP32 es una excelente manera de controlar remotamente electrodomésticos de CA. También puede leer nuestra otra guía sobre cómo controlar un módulo de relé. ESP8266.

Controlar un relé con el ESP32 es tan fácil como controlar cualquier otra salida. Todo lo que necesitas hacer es enviar señales ALTAS y BAJAS como lo harías para controlar un LED.

Puede utilizar nuestros ejemplos de servidor web que controlan salidas para controlar relés. Sólo debes prestar atención a la configuración que utilizas. Si está utilizando una configuración normalmente abierta, el relé funciona con lógica invertida. Puede utilizar los siguientes ejemplos de servidor web para controlar su retransmisión:

• Servidor web ESP32 – IDE de Arduino
• Servidor web ESP32 con SPIFFS (salidas de control)
• Servidor web ESP32/ESP8266 MicroPython: salidas de control

Obtenga más información sobre el ESP32 con nuestros recursos:

• Aprenda ESP32 con Arduino IDE (curso en vídeo + libro electrónico)
• Programación MicroPython con ESP32 y ESP8266
• Más recursos de ESP32…

Gracias por leer.

Control de Dispositivos de CA con Módulo de Relé ESP32: Tutorial y Preguntas Frecuentes

Utilizar un módulo de relé con el ESP32 es una excelente manera de controlar dispositivos de corriente alterna de forma remota. En este tutorial, vamos a explicar cómo controlar un módulo de relé con el ESP32. Vamos a ver cómo funciona un módulo de relé, cómo conectar el relé al ESP32 y cómo construir un servidor web para controlar un relé de forma remota (o varios relés).

Introducción a los Relés

Un relé es un interruptor operado eléctricamente que, al igual que cualquier otro interruptor, puede encenderse o apagarse, permitiendo que la corriente pase o no pase. Puede ser controlado con voltajes bajos, como los 3.3V proporcionados por los GPIOs del ESP32, y nos permite controlar voltajes altos como 12V, 24V o la corriente de red (230V en Europa y 120V en los Estados Unidos).

Cantidad de Canales en los Módulos de Relé

Existen diferentes módulos de relé con distintos números de canales. Hay módulos de relé con uno, dos, cuatro, ocho e incluso dieciséis canales. El número de canales determina la cantidad de salidas que podremos controlar.

Conexiones del Módulo de Relé

Para demostración, veamos el esquema de pines de un módulo de relé de 2 canales. Utilizar un módulo de relé con un número diferente de canales es similar.

1. Conexiones de Voltaje de Red: El módulo de relé mostrado en la foto anterior tiene dos conectores, cada uno con tres pines: común (COM), normalmente cerrado (NC) y normalmente abierto (NO).
2. Pines de Control: El lado de bajo voltaje tiene un conjunto de cuatro pines y otro conjunto de tres pines. El primer conjunto consta de VCC y GND para alimentar el módulo, e IN1 e IN2 para controlar los relés inferior y superior, respectivamente.

Selección de la Fuente de Alimentación

El segundo conjunto de pines consiste en GND, VCC y JD-VCC. El pin JD-VCC alimenta el electromagnet de los relés. Es importante tener en cuenta si se utiliza el jumper cap que conecta los pines VCC y JD-VCC o si se proporciona una fuente de alimentación independiente.

Preguntas Frecuentes

1. ¿Cómo puedo controlar un módulo de relé con el ESP32?

Puede controlar un módulo de relé con el ESP32 enviando señales de HIGH y LOW a los pines correspondientes del relé. Esto le permitirá encender y apagar dispositivos de CA conectados al relé de forma remota.

2. ¿Cuál es la diferencia entre una configuración normalmente abierta y normalmente cerrada en un módulo de relé?

En una configuración normalmente abierta, la corriente no fluirá a menos que se envíe una señal para cerrar el circuito. En una configuración normalmente cerrada, la corriente fluirá a menos que se envíe una señal para abrir el circuito.

3. ¿Cómo puedo controlar múltiples relés con el ESP32 a través de un servidor web?

Puede controlar múltiples relés con el ESP32 mediante un servidor web que le permita encender y apagar los relés de forma remota. Solo necesita definir el número de relés que desea controlar y asignar los pines correspondientes en el código.

Utilizando estos consejos y preguntas frecuentes, podrá controlar dispositivos de CA con un módulo de relé ESP32 de manera efectiva y segura.