Módulo de relé ESP8266 NodeMCU – Control de dispositivos de CA (servidor web)

El módulo de relé ESP8266 NodeMCU es una herramienta versátil que te permite controlar dispositivos de corriente alterna a través de un servidor web. Con esta tecnología, podrás encender y apagar luces, electrodomésticos y otros dispositivos desde la comodidad de tu smartphone o computadora. Descubre cómo funciona este emocionante dispositivo y cómo puede facilitar tu vida diaria en este artículo.

Usar un relé con el ESP8266 es una excelente manera de controlar remotamente electrodomésticos de CA. Este tutorial explica cómo controlar un módulo de relé con el ESP8266 NodeMCU. Veremos cómo funciona un módulo de relé, cómo conectar el relé al ESP8266 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 una placa ESP32: Instrucciones del módulo de relé ESP32 – 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 ESP8266, 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 ESP8266; 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 ESP8266 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.

Los dos conectores (con tres enchufes cada uno) en el lado izquierdo del módulo de relé conectan alto voltaje y los pines en el lado derecho (bajo voltaje) conectan los GPIO ESP8266.

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 generalmente 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 ESP8266 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íe una señal desde el ESP8266 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 conector de alimentación ESP8266, por lo que el módulo de relé y los circuitos ESP8266 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 ESP8266 con el optoacoplador incorporado del módulo, evitando daños al ESP8266 en caso de sobretensiones.

ESP8266: pines más seguros para usar con relés

Algunos pines del ESP8266 emiten una señal de 3,3 V cuando se inicia el ESP8266. Esto puede resultar problemático si tiene relés u otros periféricos conectados a estos GPIO.

Además, es necesario colocar algunos pines en ALTO o BAJO para iniciar el ESP8266.

Teniendo esto en cuenta, los pines ESP8266 más seguros para usar con relés son: GPIO 5, GPIO 4, GPIO 14, GPIO 12 y GPIO 13.

Para obtener más información sobre los GPIO ESP8266, consulte: Referencia de pines de ESP8266: ¿Qué pines GPIO debería utilizar?

Cableado de un módulo de relé a la placa ESP8266 NodeMCU

Conecte el módulo de relé al ESP8266 como se muestra en el siguiente diagrama. El diagrama muestra el cableado de un módulo de relé de 2 canales. Cablear 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 GPIO5Puede utilizar cualquier otro GPIO adecuado. Consulte el Manual de referencia de ESP8266 GPIO.

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

El código para controlar un relé con el ESP8266 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/esp8266-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 = 5;

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 = 5;

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 ESP8266 NodeMCU

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 ESPAsyncTCP para ESP8266

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

1. Haga clic aquí para descargar la biblioteca ESPAsyncTCP. Deberías tener una carpeta .zip en tu carpeta de Descargas.
2. Descomprima la carpeta .zip y debería obtener Maestro ESPAsyncTCP Carpeta
3. Cambie el nombre de su carpeta de Maestro ESPAsyncTCP A ESPAsyncTCP
4. mueve eso ESPAsyncTCP 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/esp8266-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 "ESP8266WiFi.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] = {5, 4, 14, 12, 13};

// 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 ESP8266 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 ESP8266 que controlan los relés.

int relayGPIOs[NUM_RELAYS] = {5, 4, 14, 12, 13};

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 a un NodeMCU ESP8266

Para fines de demostración controlamos 5 canales de retransmisión. Conecte la placa ESP8266 NodeMCU al módulo de relé como se muestra en el siguiente esquema.

demostración

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

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

Luego abra un navegador en su red local e ingrese la dirección IP ESP8266 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 ESP8266 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é. ESP32.

Controlar un relé con el ESP8266 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 otros ejemplos de servidores 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 ESP8266 – IDE de Arduino
• Servidor web ESP8266 con SPIFFS (salidas de control)
• Servidor web ESP32/ESP8266 MicroPython: salidas de control

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

• Domótica con ESP8266
• Programación MicroPython con ESP32 y ESP8266
• Más recursos de ESP8266…

Gracias por leer.

[automatic_youtube_gallery type=»search» search=»Módulo de relé ESP8266 NodeMCU – Control de dispositivos de CA (servidor web)

» limit=»1″]

Módulo de relé ESP8266 NodeMCU – Control de dispositivos de CA (servidor web)

Utilizar un relé con el ESP8266 es una excelente manera de controlar electrodomésticos de CA de forma remota. Este tutorial explica cómo controlar un módulo de relé con el ESP8266 NodeMCU. Veremos cómo funciona un módulo de relé, cómo conectar el relé al ESP8266 y construir un servidor web para controlar un relé de forma remota (o tantos relés como desees).

Preguntas Frecuentes

1. ¿Qué es un relé?

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

2. ¿Cuántos canales de relé existen?

Existen módulos de relé con diferentes números de canales. Puedes encontrar 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.

3. ¿Cómo se conecta un módulo de relé al ESP8266 NodeMCU?

Para conectar un módulo de relé al ESP8266 NodeMCU, es necesario seguir la disposición de pines correspondiente. Es importante tener en cuenta la configuración del relé y seleccionar los pines de control adecuados en el ESP8266.

4. ¿Cuáles son los pines más seguros del ESP8266 para usar con relés?

Los pines más seguros del ESP8266 para usar con relés son GPIO 5, GPIO 4, GPIO 14, GPIO 12 y GPIO 13. Estos pines garantizan un funcionamiento estable y seguro al controlar relés.

5. ¿Cómo se puede controlar múltiples relés con el ESP8266 NodeMCU?

Para controlar múltiples relés con el ESP8266 NodeMCU, es posible crear un servidor web que permita controlar todos los relés de manera remota. Utilizando librerías como ESPAsyncWebServer, es posible gestionar múltiples relés a través de una interfaz web.

Mantente al tanto de todas las novedades y tutoriales relacionados con el uso de relés con el ESP8266 visitando nuestro sitio web. Aprende a sacar el máximo provecho a tu ESP8266 y controla dispositivos de CA de forma sencilla y segura.