ESP32 Basic Starter Kit for dummys: Proyecto - 9 Trabajando con relés

Un relé (relay) es un interruptor operado eléctricamente y, como cualquier otro interruptor, se puede encender (cerrado - closed) o apagar (abierto - open), dejando pasar la corriente o no a través suyo. 

Un relé puede ser controlado con voltajes bajos, como los 3.3V proporcionado por los GPIO ESP32 y eso nos permite controlar tensiones altas como 12V, 24V o tensión de red (220V), también permite controlar radiofrecuencia por lo que permite por ejemplo conmutar líneas de alimentación de antenas.

Un relé controlado por un microprocesador es la base, entre otras cosas, de la domótica (subir y bajar persianas, abrir puertas, encender o apagar luces, etc.)

En el Kit tenemos una placa con 2 relés, pero se pueden encontrar placas con:

•  1 relé por unos 2,5 € en Aliexpress
• 2 relés
• 4 relés
• 8 relés disponibles por unos 8€ en Aliexpress 
• 16 relés disponibeles por unos 17€ en Aliexpress. 

La alimentación puede ser de 3,3 V,  5V (usar VIN pin), 12 o 24 V (Se necesita fuente externa para estos últimos voltajes)

Esquema del modulo con relés (2) cada uno de ellos tiene un terminal NO (Normalmente abierto, a falta de orden que diga lo contrario), uno COM (común, corriente a controlar) y uno NC (Normalmente cerrado, a falta de orden que diga lo contrario). Además tiene dos entradas para la alimentación  de tensión (VCC, +) y la de tierra (GND, -) y dos entradas de control IN1 y IN2. la segunda toma de alimentación cn el puente o jump permite aislar la alimentación del relé de la del ESP32.
(Observe que el tutorial del KIT aprovecha la imagen de https://randomnerdtutorials.com/)

Lógica:

• Normally Closed  (NC) (p.e. router de wifi):
• HIGH signal – La corriente no circula  (circuito abierto)
• LOW signal – La corriente circula  (circuito cerrado)
• Normally Open  (NO) (p.e una luz):
• HIGH signal – La corriente circula  (circuito cerrado)
• LOW signal – La corriente no circula (circuito abierto)

Circuiteria para probar los relés

Vamos a ver varios programas de ejemplo de más sencillos a mas complejos con el find e fijar los conceptos y abrir ventanas a su creatividad:

Programa de prueba del relé 

El programa enciende y apaga un LED siguiendo una secuencia, cada 5 segundos, y escribe en el monitor el estado. Observe que además de encenderse el LED se oye el "clic" del relé cuando actúa, pues es un componente mecánico y se enciende un microled en la placa ESP32

/*********

  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.

*********/

//  Define el GPIO 26 como salida, y 115200 la velocidad del monitor serie

const int relay = 26;

void setup() {

  Serial.begin(115200);

  pinMode(relay, OUTPUT);

}

void loop() {

  // NO Normalmente Open con LOW se cierra

  digitalWrite(relay, LOW);

  Serial.println("encendido");

  delay(5000); 

  

  // NO Normalmente Open con HIGTH  se abre

  digitalWrite(relay, HIGH);

  Serial.println("apagado");

  delay(5000);

}

Puede modificar:

• el circuito con un segundo led conectado a la salida NC de forma que cuando un led se apague el otro se encienda y viceversa
• el programa para incluir el control del GPIO26 y con ello el segundo relé

Programa para controlar un relé mediante un botón o dos botones

const int relay = 26;

const int buttonPin = 4; 

// Inicialización  de la salida serie y GPIO

int buttonState = 0;

void setup() {

  Serial.begin(115200);

  pinMode(buttonPin, INPUT); 

  pinMode(relay, OUTPUT);

}

void loop() 

{

  // Lee el estado del botón GPIO 4

  buttonState = digitalRead(buttonPin);

  Serial.println(buttonState); 

  // Si está HIGH entonces ... sino ... 

  if (buttonState == HIGH) 

  {

    // Enciende LED ON

    digitalWrite(relay, LOW);

    Serial.println("OFF"); 

  } else {

    // Apaga LED OFF

    digitalWrite(relay, HIGH);

    Serial.println("ON");  

}}

Programa para controlar un relé mediante un código (se puede mejorar para quen que no cominece el ciclo encendido, pero en otro momento más)

// Definiciones GPIO

const int relay = 26;

char val;

// Inicialización de la salida serie y GPIO

void setup() {

Serial.begin(115200);

pinMode(relay, OUTPUT);

}

void loop()

{

if (Serial.available() > 0)

{

val=Serial.read();

if ((val == '\n') || (val == '\r')) { }

else if (val == 'E') {

digitalWrite(relay, LOW);

Serial.println("Enciende");}

else {

digitalWrite(relay, HIGH);

Serial.println("Apaga");}

}}

Programa para controlar un relé mediante web

Estos programas de control mediante web server son muy potentes y muestran el potencial de los servidores web y trabajando en  microprocesadores, pero desde el punto de vista didáctico tienen poco valor pues la programación es compleja.

Para este segundo programa del proyecto en el que se controlan hasta 5 relés desde un navegador  se necesita instalar dos librerias nuevas:

• https://codeload.github.com/me-no-dev/AsyncTCP/zip/refs/heads/master
• https://codeload.github.com/me-no-dev/ESPAsyncWebServer/zip/refs/heads/master

El proceso de instalación es el siguiente:

• Entrar en las URL que provocarán la descarga del ZIP correpondiente
• Desde Android IDE hacer Sketch -> Incluir biblioteca (libreria) - > Añadir biblioteca ZIP

A estas alturas no decubriré nada nuevo si digo que no se localiza el fuente donde dice el manual asíe s que lo buscamos por Google "ESP32 Relay Module – Control AC Appliances (Web Server)"

/*********

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.

*********/

// Incluye las bibliotecas

#include "WiFi.h"

#include "ESPAsyncWebServer.h"

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

#define RELAY_NO true

// Numero de reles a controlar

#define NUM_RELAYS 5

// asignacion de GPIO para los 5 reles

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

// Replace with your network credentials

const char* ssid = "xxx";

const char* password = "xxx";

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

}

Pagina web de control de los relés

Continúa en: Proyecto - 10 Sincronización de interruptores fisicos y virtuales

Prohibida la reproducción parcial o total de este artículo sin permiso previo del autor