Sind Sie ein Experte? Nutzen Sie Gladys schon lange? In diesem Fall: Gehen Sie einfach weiter, hier gibt es nichts zu sehen, vielen Dank für Ihren Besuch 
Sind Sie Anfänger? Begriffe wie „Energie“, „Leistung“, „Watt“ sagen Ihnen nichts? Dann kommen Sie näher, treten Sie ein, werfen Sie einen Blick. Vielen Dank, dass Sie gekommen sind 
Voraussetzungen:
-
Steuerbare Batterie
-
Aktualisierte Informationen zu Ihrem Stromverbrauch, die am Zähler abgelesen wurden
-
Node-RED
-
Gladys
Der unten beschriebene Fluss besteht aus drei Teilen. Der erste Teil ermöglicht die Bestimmung des aktuellen Stromverbrauchs an Ihrem Zähler. Diese Daten werden dann verwendet, um eine erzwungene Entladung der Batterie eines Balkonkraftwerks durchzuführen. Der dritte Teil generiert anschließend zusätzliche Informationen für die Schleife oder den Fluss. Hinweis: Wir nutzen hier nur die Batterie, ohne Solarmodule oder Verkabelung… Ideal für eine Mietwohnung oder wenn Sie keine Kabelkanäle verlegen oder graben möchten.
Teil 1:
Um den Stromzähler abzufragen, wird ein Produkt der Firma Wattwächter verwendet. Dieser IR-Kopf wird am Zähler des Stromanbieters befestigt und liefert jederzeit den aktuellen Verbrauch im Netz. Einer der Vorteile besteht darin, dass der Zähler über MQTT oder Modbus abgefragt werden kann.
Was für Sie wichtig ist, ist einfach, dass Sie am Ende dieses ersten Teils den aktuellen Verbrauch Ihres Zählers in Watt erhalten. Das Produkt, das Sie dafür verwenden, ist egal. Der Batteriehersteller gibt die zugelassenen Produkte an, aber wenn Sie bereits ein anderes Produkt haben, sind Sie hier richtig.
Ersetzen Sie diesen Teil gegebenenfalls durch Ihre eigenen technischen Lösungen.
Struktur:
Injektionsknoten: Anfang des Flusses. Debug-Ausgabe in Form von Datum und Uhrzeit, um zu überprüfen, welche Uhrzeit verwendet wird.
Modbus-Abfrage des IR-Kopfes der Firma Wattwächter: Unit-ID: 1, FC3 Reading Holding Register, Adresse 40088, Menge 1
Funktionsverarbeitung der Werte:
// ****************
let payload = msg.payload;
let wert = 0;
if (payload && payload.data && Array.isArray(payload.data) && payload.data.length > 0) {
wert = payload.data[0];
}
// int16-Korrektur für negative Werte (Einspeisung)
if (wert > 32767) {
wert = wert - 65536;
}
// Wert im Flow-Kontext speichern
flow.set(« Hausübergabepunkt », wert);
// WICHTIG: Wir triggern hier direkt die Berechnung, sobald ein neuer Zählerwert kommt
msg.payload = wert;
return msg;
// ****************
Die Zeile « flow.set(« Hausübergabepunkt », wert) » ist entscheidend: Der aktuell erhaltene Wert in Watt wird im Fluss für die spätere Verwendung gespeichert.
Am Ende des ersten Teils des Flusses wird auch der aktuelle Batteriestand in Prozent abgefragt. Dieser Wert ist wichtig, um eine Tiefentladung der Batterie zu vermeiden:
Modbus-Abfrage der Batterie: Unit-ID: 1, FC3 Reading Holding Register, Register 37612, Menge 1
Anschließend geht der Fluss durch einen Switch. Dieser ermöglicht die Entscheidung, ob die Verarbeitung fortgesetzt oder beendet wird.
Variante A:
Die Batterie ist bereits entladen. Der Switch-Knoten gibt dann die Fernsteuerung an die Smartphone-App des Herstellers Solakon mit der folgenden Funktion zurück:
// ****************
// msg.payload zur Rückgabe der Kontrolle an die Smartphone-App
msg.payload = {
value:[0], // 0 deaktiviert den Remote-Modus
fc: 16, // Holding Register beschreiben
unitid: 1, // Modbus-ID Ihres Solakon ONE
address: 46001, // Startadresse
quantity: 1 // Nur dieses eine Register beschreiben
};
// 4. Nachricht an den Modbus-Node weiterleiten
return msg;
// ****************
Der Wert von msg.payload wird anschließend einfach mit einem modbus-flex-write-Knoten weitergeleitet.
Variante B:
Der Prozess wird fortgesetzt: Wenn die Batterie noch mehr als 12 % hat, geht der Fluss zum nächsten Schritt über.
Wir generieren die notwendigen Informationen mit einer Funktion.
// ****************
// 1. Werte aus dem Speicher holen
let netzBezug = flow.get(« Hausübergabepunkt ») || 0;
// Holt den Wert, den Ihre aktualisierte Batterie-Funktion speichert
let aktuelleEntladung = flow.get(« AktuelleBatterieEntladung »);
// Falls Node-RED frisch startet und der Speicher leer ist,
// nehmen wir die 100W als sicheren Startwert an
if (aktuelleEntladung === undefined || aktuelleEntladung === null) {
aktuelleEntladung = 100;
}
// 2. Den ECHTEN Hausverbrauch berechnen (Zählerstand + aktuelle Entladeleistung)
let echterHausverbrauch = netzBezug + aktuelleEntladung;
// 3. Zielwert für die Batterie setzen (entspricht dem echten Verbrauch)
let targetPower = echterHausverbrauch;
// 4. Sicherheitsgrenzen einhalten (0 bis maximal 800 Watt)
targetPower = Math.round(targetPower);
if (targetPower < 0) {
targetPower = 0;
}
if (targetPower > 800) {
targetPower = 800;
}
// 5. 32-Bit-Split für das Solakon Modbus-Register (I32 Big Endian)
const powerHigh = (targetPower >> 16) & 0xFFFF;
const powerLow = targetPower & 0xFFFF;
// msg.payload für das Modbus-Flex-Write Node vorbereiten
msg.payload = {
value: [5, 240, powerHigh, powerLow], // 5 = Entlademodus
fc: 16,
unitid: 1,
address: 46001,
quantity: 4
};
return msg;
// ****************
Wir senden diese Information einfach an die Batterie über einen Modbus Flex-Write-Befehl.
Das war’s…
Wir haben das Produkt der Firma Wattwächter abgefragt, um den aktuellen Stromverbrauch zu ermitteln, den aktuellen Zustand der Batterie abgerufen, die notwendige Entladung aus diesen Daten berechnet und diese Berechnung an die Batterie gesendet.
Aber:
Es ist ein Zyklus, das heißt, der Fluss ist eigentlich erst beendet, wenn wir ihn beenden oder die Batterie leer ist, also:
Wir warten 5 Sekunden mit einem „delay“-Knoten, damit die Batterie die Werte speichern kann.
Anschließend fragen wir die Batterie erneut über Modbus ab:
Unit-ID: 1, FC3 Reading Holding Register, Register 39134, Menge 2
Dann verwenden wir eine weitere Funktion, um die neuen Werte in die Schleife zu integrieren.
Name im Bild: « Batteriestatus »
Funktion:
//************************************************************
if (!msg.payload || !msg.payload.buffer) {
node.error("Fehler: Kein Buffer im msg.payload gefunden.");
return null;
}
const buf = msg.payload.buffer;
const rawValue = buf.readInt32BE(0);
// Umrechnung exakt wie bei der funktionierenden « anlage »-Node
let wert = rawValue / 1000;
wert = Math.round(wert * 1000);
wert = wert * -1; // Macht den Wert für die Anzeige negativ (z.B. -239)
// Für die Anzeige im Dashboard / Debug (wird nun korrekt angezeigt!)
msg.payload = wert;
msg.topic = « solakon/status/batterie »;
// WICHTIG: Für unsere Steuerungs-Rechnung brauchen wir den Wert POSITIV im Speicher
// Math.abs(-239) macht daraus +239 Watt
flow.set(« AktuelleBatterieEntladung », Math.abs(wert));
return msg;
// ********************************************************
Wir warten dann 2 Minuten, bevor der Zyklus von vorne beginnt.
Das heißt, nach zwei Minuten wird der Leistungscontroller erneut abgefragt und die neuen Daten werden schließlich in der Funktion „Erzwungene Entladung“ neu berechnet und dann an die Batterie übertragen.
Hier ist der vollständige Zyklus mit den entsprechenden Debug-Ausgaben:
Dies ist der erste Teil des Tutorials. Im nächsten Teil werden wir die automatische Batterieladung zu festgelegten Zeiten (z. B. im Rahmen von dynamischen Stromtarifen oder ähnlichem; auch eine andere Photovoltaikanlage könnte in Betracht gezogen werden) behandeln; wir werden auch erklären, wie man anhand der Watt-Informationen von der Batterie oder dem Hausanschluss ein präzises Energiemonitoringsystem für Gladys einrichten kann.
Bis dahin,
viel Spaß beim Ausprobieren
Mit freundlichen Grüßen
Thomas