Wifi conectado a Relé, ¿siempre encendido o siempre apagado?

#1
He preparado un circuito con una placa Wemos D1 (programada con el IDE de Arduino) para que actúe sobre un relé de alta potencia:



El proyecto es colocarlo a la entrada de un acuario, para en caso de necesidad cortar la alimentación eléctrica de todos los mecanismos del acuario vía wifi.
Inicialmente he pensado en conectar la alimentación del acuario en la parte NC (normalmente cerrada) para que el relé esté apagado siempre, y la electricidad del acuario siempre conectada, y que el relé solo lo encienda en caso de necesidad (léase "desastre" con 500 litros de agua en el salón).
El problema que se me presenta es que en caso de querer cortar la alimentación (encender el relé), si se corta la corriente eléctrica (del edificio o de la zona), al volver la alimentación a la placa Wemos, vuelve a la configuración inicial, o sea el relé apagado, con lo cual vuelve a conectar la corriente eléctrica al acuario. :(:(

Las dudas son:

1.- Configurar la placa Wemos D1 con el relé apagado y conectado al circuito NO (normalemtne abierto), de manera que lo conecte manualmente, y en caso de corte eléctrico al volver la electricidad quedaría el relé apagado. Esta alternativa significa tener SIEMPRE el relé encendido ¿es correcto mantenerlo SIEMPRE encendido? Lo digo por el riesgo de desgaste mayor por estar siempre activado el electroimán.

2.- Colocarle al Wemos una batería, de manera que si se corta el suministro eléctrico no se apague y no cambie el estado. No sé, pero me parece más complicado esto de colocarle una batería (y que se conecte simultáneamente a la placa para que no se reinicie)

3.- Grabar una configuración en el EEPROM del Wemos D1, que no sé como se hace, pero si creen que es la mejor opción, pues a estudiar... :) :LOL:
 
#2
Hola albertoG, quizas haya mejores opciones, pero lo que yo haría sería declarar una bandera con el estado del relé, es decir 1 ó 0, y cada vez que quieras conmutar el estado del relé, ademas de conmutarlo, escribir el estado de la bandera en la EEPROM. Así cada vez que tu placa inicie luego de un corte de luz, leerás en la EEPROM el valor con el que quedó la bandera, y pondras la salida en alto o bajo según corresponda. En google podes encontrar como ultilizar la libreria EEPROM con la IDE de Arduino.
 
#4
El desgaste del relevador no es en la bobina por estar siempre activa, sino en los contactos por la conmutación constante (el movimiento y la chispa generada).
 
#5
El desgaste del relevador no es en la bobina por estar siempre activa, sino en los contactos por la conmutación constante (el movimiento y la chispa generada).
Entonces si el relé está siempre encendido (se apagaría excepcionalmente, solo en caso de emergencia) la duración será la misma que si estuviese apagado?
El calor generado (supongo que encendido se calentará más) no reducirá sensiblemente la vida del relé?
 
#6
Se calienta como todo dispositivo pero la potencia es poca, creo que para uno de 12V la potencia estaba en orden 1W, las bobinas soportan cerca de 150°C, me preocuparía si el plástico comienza a derretirse.
 
#7
Hace unos 20 años un cliente de mi viejo le pidió un dispositivo de emergencia para bombas de petróleo. Las bombas no bombeaban petróleo, sino agua a los pozos, para que el crudo suba. Estas bombas estaban (están) alimentadas por motores a gas de 600HP en el medio de la nada en Comodoro Rivadavia. Si se rompen, no hay nadie que lo vea, por lo que había que ingeniar un sistema de parada de emergencia conectado a PLC y la única referencia para la detección era un flotante que se conectaba a masa.

Yo lo solucioné con un solo relé doble inversor. Cortaba por quedarse sin aceite conectando a masa el flotante con el marcador de nivel inferior, o por entrada de agua al conectar el flotante con el marcador de nivel superior. Una fuente, un relé, y bornera.

¿A qué voy con ésto? Antes de largarte a desarrollar un software, pensá la LÓGICA DE RELÉ. Álgebra de Boole.

A veces la solución es muy simple.

Pensá en el estado inicial al alimentar el sistema. Pensá que pasa al cortarle la alimentación. Quizá lo solucionas sin WiFi ni nada externo mas que la alimentación y el "detector de desastre".
Y no pienses en "encender el relé". Amigate con los conceptos de NA y NC. Normal es el relé "apagado". Cuando estos conceptos te queden claros en la cabeza (no porque sean difícil de entender, sino a que te queden "automatizados" en la cabeza) vas a ver que SIN software podés lograr cosas muy interesantes.

Si te es mas fácil con software, pensá en algo simple como "if, then, else". Pensalo como relé.
 
Última edición:
#8
Pues he estado intentando como me sugirió gonza094 grabar el estado del Relé en la EEPROM.
Inicialmente le grabé un valor de cero ("0") en la EEPROM y luego según el estado del relé (0 ó 1) grabar en la EEPROM, pero no sé qué estaré haciendo mal porque siempre mantiene el valor cero, no cambia.
Pongo el sketch por si alguien me puede indicar qué estoy haciendo mal:

Código:
//Control de un Relé que trabaja apagado (NC) y al activarse 
//corta toda la electricidad del acuario

#include <ESP8266WiFi.h>
#include <EEPROM.h>

int addr = 0;    //Dirección en la memoria EEPROM
int EstadoRele;
byte EstadoEEPROM = EEPROM.read(addr);
const char* ssid = "Red"; // Red utilizada para la comunicación WiFi
const char* password = "Clave"; // Clave de acceso para la red inalámbrica
int RelayPin = 13; // GPIO13 D7 MOSI
WiFiServer server(80);

void setup() 
{
Serial.begin(115200);
//EEPROM.write(addr,0);  //Solo la primera vez para grabar un cero en la EEPROM
delay(10);
pinMode(RelayPin, OUTPUT);
digitalWrite(RelayPin, EstadoEEPROM); //Enciende o apaga según el valor de la EEPROM
ConectaWifi();  // Connect to WiFi network
}

void loop() {
// Check if a client has connected:
WiFiClient client = server.available();
if (!client) 
{return;}
// Wait until the client sends some data
while(!client.available()){
delay(1);
}
// Read the first line of the request
String request = client.readStringUntil('\r');
Serial.println(request);
client.flush();
// Match the request
if (request.indexOf("/RELAY=ON") != -1) 
{
digitalWrite(RelayPin, 0);  //Relé encendido, acuario apagado
EstadoRele = 0;
Serial.println();
Serial.println("Orden Ejecutada: Relay encendido, Acuario apagado");
}
if (request.indexOf("/RELAY=OFF") != -1) {
digitalWrite(RelayPin, 1);   //Relé apagado, acuario encendido
EstadoRele = 1;
Serial.println();
Serial.println("Orden Ejecutada: Relay apagado, Acuario encendido");
}
// Set RelayPin according to the request
// Return the response
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println(""); // do not forget this one
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.print("El Relay esta ahora: ");
if(EstadoRele == 0) {
client.print("ENCENDIDO (CORRIENTE CORTADA)");
} else {
client.print("APAGADO (ACUARIO FUNCIONANDO)");
}
client.println("<br><br>");
client.println("<a href=\"/RELAY=ON\"\"><button>ENCENDER (CORTAR LA CORRIENTE)</button></a>");
client.println("<a href=\"/RELAY=OFF\"\"><button>APAGAR (ACUARIO ENCENDIDO)</button></a><br/>");
client.println("</html>");
delay(1);
Serial.println("");
if (EstadoRele != EstadoEEPROM)
{EEPROM.write(addr,EstadoRele); Serial.print("EEPROM ahora es ");Serial.println(EstadoEEPROM);}
else
{Serial.print("EEPROM ahora es ");Serial.println(EstadoEEPROM);}
Serial.println("");
Serial.println("Esperando Mandato");
Serial.println("");
}

void ConectaWifi(){
Serial.println();
Serial.println();
Serial.print("Conectando a ");
Serial.println(ssid);
Serial.print("EEPROM: ");
Serial.println(EstadoEEPROM);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) 
{
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado");
server.begin(); // Start the server
Serial.println("Servidor iniciado");
// Print the IP address:
Serial.print("Utilizar esta URL para conectar: ");
Serial.print("http://");
Serial.print(WiFi.localIP());
Serial.println("/");}
 
#10
Antes de grabar 0 en el setup, realiza la comprobación del estado o lo estarás reiniciando y no tendrá caso usar la EEPROM.
No llego a entenderlo, solo grabé cero en la EEPRON una vez y luego comenté esa línea para que no vuelva a grabar esa orden.
Al final del loop() comparo el valor del relé con el valor de la EEPROM y si es diferente entonces le escribo el nuevo valor, pero algo no funciona...
 
#11
Pues era imposible escribir en la EEPROM de un módulo ESP8266, ninguno tiene EEPROM :oops::eek:
Hay que reservar un espacio en la memoria flash (La Wemos y las Nodemcu tienen 4 megas de memoria flash).
En fin, había que leer un poco más...:cry::confused::eek::oops::LOL:
 
Última edición:
#12
De todas formas la mejor manera (para mí) de resoverlo ha sido a través de una aplicación que funciona con iOS o con Android: Blynk, que tiene una función que en caso de corte de energía o pérdida de señal, al reconectarse vuelve a colocar todas las entradas y salidas al mismo estado que estaban al momento del corte.
Creo que con esto he resuleto la consulta, y por si a alguien le puede resultar de utilidad las conclusiones son:
Relé Normalmente Cerrado y controlado con una placa Nodemcu V3 a través de la app Blynk, ambos alimentados con una fuente de alimentación AC DC de 5v 2A DC de salida.
Un saludo.
 
#13
De todas formas la mejor manera (para mí) de resoverlo ha sido a través de una aplicación que funciona con iOS o con Android: Blynk, que tiene una función que en caso de corte de energía o pérdida de señal, al reconectarse vuelve a colocar todas las entradas y salidas al mismo estado que estaban al momento del corte.
Creo que con esto he resuleto la consulta, y por si a alguien le puede resultar de utilidad las conclusiones son:
Relé Normalmente Cerrado y controlado con una placa Nodemcu V3 a través de la app Blynk, ambos alimentados con una fuente de alimentación AC DC de 5v 2A DC de salida.
Un saludo.
Y si falla el wifi cuando se reinicia? Otra opcion que podes hacer con los modulos ESP es guardar archivos, osea guardas un archivo por ejemplo rele.txt que dentro contenga el ultimo valor y que cuando se encienda lo lea y listo. La libreria es #include "FS.h"
 
#14
Buenos días, para grabar en "EEPROM" con el esp8266 te faltaron un par de lineas de código.

Código:
#include <ESP8266WiFi.h>
#include <EEPROM.h>

size_t EPROM_MEMORY_SIZE= 512;

int direccion=0;
int dato = 0;

void setup() 
{
    EEPROM.begin(EPROM_MEMORY_SIZE); //inicia eeprom

    EEPROM.write(direccion,dato);
    delay(100);
    EEPROM.comit();
}
A parte de las funciones
EEPROM.Write(address, byte)
EEPROM.Read(address)

Tienes estas otras bastante interesantes:
EEPROM.Put(address, variable)
EEPROM.Get(address, variable)
EEPROM.Update(address, variable)

Un saludo.
 
#15
Buenos días, para grabar en "EEPROM" con el esp8266 te faltaron un par de lineas de código.

Código:
#include <ESP8266WiFi.h>
#include <EEPROM.h>

size_t EPROM_MEMORY_SIZE= 512;

int direccion=0;
int dato = 0;

void setup() 
{
    EEPROM.begin(EPROM_MEMORY_SIZE); //inicia eeprom

    EEPROM.write(direccion,dato);
    delay(100);
    EEPROM.comit();
}
A parte de las funciones
EEPROM.Write(address, byte)
EEPROM.Read(address)

Tienes estas otras bastante interesantes:
EEPROM.Put(address, variable)
EEPROM.Get(address, variable)
EEPROM.Update(address, variable)

Un saludo.
Gracias por la info, nunca la habia podido usar, lo probare! Igual el sistema de archivos tambien esta muy bueno para usar.
 

Temas similares


Arriba