Hola a todos, retomamos ahora el tutorial. Hoy, les voy a mostrar cómo, a partir de un sensor de energía que solo proporciona los valores de potencia actuales en vatios, implementar un sistema de seguimiento del consumo de energía (kWh) a través de Node-RED.
¡Diviértanse…
Como mostré en mi último tutorial « Control de una batería solar a través de Node-RED – Gladys », es relativamente sencillo crear un sistema de control en Node-RED. Los resultados pueden luego ser transmitidos a Gladys a través de Matter, MatterBridge o MQTT.
Pero exploremos primero otra vía. Echemos un vistazo a Europa: mientras el francés, partidario de la energía nuclear, sacude la cabeza y el « Michel » alemán frunce el ceño, lleno de preocupaciones, ¿qué está pasando allí? Los austriacos, por su parte, escalan las montañas desde hace décadas y las salpican con paneles solares de balcón. Pero también existen numerosos otros productos solares de calidad y asequibles. Por ejemplo, la empresa MyPV ofrece desde hace tiempo un elemento calefactor en su gama. Se llama AC ELWA y es controlable (esto no es publicidad, solo un ejemplo)…
Veamos qué podemos hacer con ello…
Esta resistencia calefactora puede ser controlada a través de una solicitud HTTP; en otras palabras, basta con enviar comandos a la resistencia, como se haría con un navegador, y observar lo que ocurre. En Node-RED, esto se realiza utilizando un nodo llamado « http request »:
¿Qué ocurre si introducimos exactamente este comando en un navegador y lo enviamos (el calentador nos devuelve toda la información en forma de documento XML):
y es precisamente esta entrada « power » la que nos interesa. El nodo siguiente es, por tanto, un « nodo XML » que permite formatear correctamente el valor devuelto por la solicitud HTTP:
Ahora tenemos los datos en Node Red y solo tenemos que leer la fecha correcta con el valor « power », lo hacemos con un nodo de función y una pequeña función:
Por lo tanto, ahora tenemos, en nuestro flujo, en msg.payload, el valor actual de la potencia de la resistencia. Es aquí donde ocurre la magia. En otra función, procedemos simplemente de la siguiente manera:
Recogemos sistemáticamente los datos recibidos, los convertimos en kWh, los añadimos a la pila y, cuando la pila interna (2 elementos) está llena, pasamos al siguiente paso. En otras palabras: la pila contiene dos valores. El flujo completo se lanza cada 15 minutos (volveremos a esto en un momento), recoge dos valores y devuelve cada 30 minutos el valor en kWh de la resistencia calefactora, es decir, su potencia durante un período de 30 minutos.
Aquí está la función:
// ***************************************************************
// Consulta de la medida actual
let watt = msg.payload;
if (watt === 2147483648) {
watt = 0;
}
// 1. Leer las dos memorias
let messungen = flow.get(« solar_messungen ») || ;
// Obtener el total actual de los contadores (importante para Gladys)
let kwhGesamtzaehler = flow.get(« solar_kwh_gesamt ») || 0;
messungen.push(watt);
// 2. Verificar si hemos registrado 2 medidas (30 min)
if (messungen.length >= 2) {
// Calcular los dos bloques "Wh" (vatios × 0,25 hora)
let wh1 = messungen[0] * 0.25;
let wh2 = messungen[1] * 0.25;
// Consumo de las últimas 30 minutos en kWh
let kwh30Min = (wh1 + wh2) / 1000;
// Sumar el consumo al contador general
kwhGesamtzaehler += kwh30Min;
// Redondear el valor a 3 decimales
kwhGesamtzaehler = Math.round(kwhGesamtzaehler * 1000) / 1000;
// 3. Preparar la memoria para las próximas 30 minutos
flow.set("solar_messungen", []); // Vaciar mediciones de 15 minutos
flow.set("solar_kwh_gesamt", kwhGesamtzaehler); // Guardar contador general permanentemente
// 4. Enviar mensaje a Gladys
msg.topic = "solar-wr/kwh-total";
msg.payload = {
wr_zaehler_kwh: kwhGesamtzaehler
}; // Gladys recibe el contador acumulado
return msg;
} else {
// Si es el primer valor medido, guardarlo en la memoria
flow.set(« solar_messungen », messungen);
return null;
}
// ***********************************************************************
Aquí es donde se inscribe esta función en el flujo:
Comenzamos añadiendo un nodo « inject » y lo configuramos de manera que inicie el flujo cada 15 minutos, en el ejemplo entre las 10 a.m. y las 8 p.m. todos los días
Aquí están las salidas de depuración. Realiza dos recolecciones, luego envía los datos:
Solo nos queda enviar los datos a MQTT al final del flujo utilizando « mqtt out », luego podremos continuar en Gladys 
En Gladys, necesitamos el protocolo MQTT, que debe ser accesible:
El resto es luego muy sencillo. Paso 1: Crear un dispositivo MQTT virtual:
Paso 2: Añadimos una función de supervisión del consumo de energía:
Paso 3: En las funciones avanzadas del sensor de energía, asignamos los valores a los datos del tema MQTT.
Aquí están las informaciones, vienen por lo tanto de Node Red, última función y luego van a través de MQTT a Gladys:
En la sección « Supervisión de energía », verifique nuevamente si el nuevo dispositivo de supervisión de energía ha sido asignado correctamente:
Solo queda elegir una tarifa de energía adecuada, luego indicar la resistencia calefactora como contador.
Es todo…
Añada luego un seguimiento de energía en el tablero y indique la resistencia calefactora como fuente de datos:
El resultado:
Agradezco a todos los que me ayudaron a superar mis dificultades de principiante. Si detectas un error, no dudes en hacérmelo saber. Si ves una manera de simplificar las cosas, házmelo saber.
En este tutorial, por lo tanto, ha descubierto un método para consultar un contador de energía local a través de una solicitud HTTP, luego crear un sistema de supervisión de consumo de energía adecuado en Gladys.
¡Diviértanse, cordialmente, Thomas