¿Eres un experto? ¿Llevas mucho tiempo usando Gladys? En ese caso, no dudes: sigue tu camino, no hay nada que ver aquí, gracias por tu visita 
¿Eres principiante? ¿Términos como «energía», «potencia», «vatio», etc. no te dicen nada? Entonces acércate, entra, echa un vistazo. Muchas gracias por venir 
Requisitos previos:
-
Batería controlable
-
Información actualizada sobre tu consumo de electricidad registrada en el contador
-
Node-RED
-
Gladys
El flujo descrito a continuación se compone de tres partes. La primera parte permite determinar el consumo eléctrico actual en tu contador. Estos datos se utilizan luego para realizar una descarga forzada de la batería de una central eléctrica de balcón. La tercera parte genera luego información adicional para el bucle o el flujo. Nota: aquí solo utilizamos la batería, sin paneles solares ni cableado… Ideal para un apartamento en alquiler o si no quieres colocar canaletas de cables ni cavar.
Parte 1:
Para consultar el contador eléctrico, se utiliza un producto de la empresa Wattwächter. Esta cabeza IR se fija en el contador del proveedor de electricidad y proporciona en todo momento el consumo actual en la red. Una de las ventajas reside en la posibilidad de consultar el contador a través de MQTT o Modbus.
Lo que importa para ti es simplemente que al final de esta primera parte obtengas el consumo actual de tu contador en vatios. El producto que utilices para ello no tiene importancia. El fabricante de baterías indica los productos homologados, pero si ya dispones de otro producto, estás en el lugar adecuado.
Sustituye, por tanto, esta parte, si es necesario, por tus propias soluciones técnicas.
Estructura:
Nodo de inyección: inicio del flujo. Salida de depuración en forma de fecha y hora para verificar qué hora se está utilizando.
Consulta Modbus de la cabeza IR de la empresa Wattwächter: ID de unidad: 1, lectura FC3 del registro de mantenimiento en la dirección 40088, cantidad 1
Función de procesamiento de valores:
// ********************************************
let payload = msg.payload;
let wert = 0;
if (payload && payload.data && Array.isArray(payload.data) && payload.data.length > 0) {
wert = payload.data\[0\];
}
// Corrección int16 para valores negativos (inyección)
if (wert > 32767) {
wert = wert - 65536;
}
// Guardar el valor en el contexto del flujo
flow.set(« Hausuebergabepunkt », wert);
// IMPORTANTE: Aquí desencadenamos directamente el cálculo tan pronto como llega un nuevo valor del contador
msg.payload = wert;
return msg;
// *******************************************************
La línea « flow.set(« Punto de transferencia doméstico », valor) » es determinante: el valor en vatios actualmente obtenido se registra en el flujo para su uso posterior.
Al final de la primera parte del flujo, también se consulta el nivel actual de la batería en porcentaje. Este valor es importante para evitar una descarga profunda de la batería:
Consulta Modbus de la batería: ID de unidad: 1, lectura FC3 del registro de mantenimiento, registro 37612, cantidad 1
A continuación, el flujo pasa por un interruptor. Este permite determinar si el procesamiento continúa o se detiene.
Variante A:
La batería ya está descargada. El nodo interruptor devuelve entonces el control remoto a la aplicación para smartphone del fabricante Solakon mediante la siguiente función:
// ********************************************
// msg.payload para devolver el control a la aplicación de smartphone
msg.payload = {
value:\[0\], // 0 desactiva el modo remoto
fc: 16, // Describir registros de mantenimiento
unitid: 1, // ID de Modbus de tu Solakon ONE
address: 46001, // Dirección de inicio
quantity: 1 // Solo describir este registro
};
// 4. Enviar mensaje al nodo Modbus
return msg;
// *********************************************************
El valor de msg.payload se transmite luego simplemente mediante un nodo modbus-flex-write.
Variante B:
El proceso continúa: si la batería aún tiene más del 12%, por ejemplo, el flujo pasa a la siguiente etapa.
Generamos la información necesaria mediante una función.
// *************************************************************
// 1. Obtener valores de la memoria
let netzBezug = flow.get(« Hausuebergabepunkt ») || 0;
// Obtiene el valor que guarda tu función de batería actualizada
let aktuelleEntladung = flow.get(« AktuelleBatterieEntladung »);
// Si Node-RED se inicia de nuevo y la memoria está vacía,
// tomamos los 100W como valor de inicio seguro
if (aktuelleEntladung === undefined || aktuelleEntladung === null) {
aktuelleEntladung = 100;
}
// 2. Calcular el CONSUMO REAL de la casa (lectura del contador + potencia de descarga actual)
let echterHausverbrauch = netzBezug + aktuelleEntladung;
// 3. Establecer el valor objetivo para la batería (corresponde al consumo real)
let targetPower = echterHausverbrauch;
// 4. Respetar los límites de seguridad (0 hasta un máximo de 800 vatios)
targetPower = Math.round(targetPower);
if (targetPower < 0) {
targetPower = 0;
}
if (targetPower > 800) {
targetPower = 800;
}
// 5. Dividir en 32 bits para el registro Modbus de Solakon (I32 Big Endian)
const powerHigh = (targetPower >> 16) & 0xFFFF;
const powerLow = targetPower & 0xFFFF;
// Preparar msg.payload para el nodo Modbus-Flex-Write
msg.payload = {
value: \[5, 240, powerHigh, powerLow\], // 5 = modo de descarga
fc: 16,
unitid: 1,
address: 46001,
quantity: 4
};
return msg;
// ******************************************************************
Simplemente enviamos esta información a la batería mediante un comando Modbus Flex-Write.
¡Listo…
Hemos consultado el producto de la empresa Wattwächter para conocer el consumo eléctrico actual, recuperado el estado actual de la batería, calculado la descarga necesaria a partir de estos datos y enviado este cálculo a la batería.
Pero:
Es un ciclo, es decir, el flujo solo está realmente terminado cuando lo detenemos o la batería está descargada, por lo tanto:
Esperamos 5 segundos mediante un nodo « delay » para que la batería pueda registrar los valores.
Luego, consultamos nuevamente la batería a través de Modbus:
ID de unidad: 1, lectura FC3 del registro de mantenimiento, registro 39134, cantidad 2
Luego, utilizamos otra función para integrar los nuevos valores en el bucle.
Nombre en la imagen: « Estado de la batería »
Función:
//****************************************************
if (!msg.payload || !msg.payload.buffer) {
node.error("Error: No se encontró buffer en msg.payload.");
return null;
}
const buf = msg.payload.buffer;
const rawValue = buf.readInt32BE(0);
// Conversión exacta como en el nodo « anlage » funcional
let wert = rawValue / 1000;
wert = Math.round(wert * 1000);
wert = wert * -1; // Hace que el valor sea negativo para la visualización (por ejemplo, -239)
// Para la visualización en el panel de control / depuración (¡ahora se muestra correctamente!)
msg.payload = wert;
msg.topic = « solakon/status/batterie »;
// IMPORTANTE: Para nuestro cálculo de control, necesitamos el valor POSITIVO en la memoria
// Math.abs(-239) lo convierte en +239 vatios
flow.set(« AktuelleBatterieEntladung », Math.abs(wert));
return msg;
// ********************************************************
Esperamos luego 2 minutos, después de lo cual el ciclo se reinicia desde el principio.
En otras palabras, después de dos minutos, el controlador de potencia es interrogado nuevamente y los nuevos datos son finalmente recalculados en la función « Descarga forzada », luego transmitidos a la batería.
Aquí está el ciclo completo con las salidas de depuración correspondientes :
Esta es la primera parte del tutorial. En la siguiente parte, abordaremos la recarga automática de la batería a horarios que definiremos (por ejemplo, en el contexto de tarifas de electricidad dinámicas o similares; también podría considerarse otra instalación fotovoltaica); también explicaremos cómo, a partir de las informaciones en vatios provenientes de la batería o del punto de conexión de la vivienda, establecer un sistema de monitoreo energético preciso para Gladys.
Hasta entonces,
¡Buena exploración!
Cordialmente
Thomas