Hallo zusammen, wir setzen den Tutorial jetzt fort. Heute zeige ich euch, wie man ausgehend von einem Energiesensor, der nur die aktuellen Leistungswerte in Watt liefert, ein System zur Verfolgung des Energieverbrauchs (kWh) über Node-RED einrichtet.
Viel Spaß…
Wie ich in meinem letzten Tutorial « Steuerung einer Solarbatterie über Node-RED – Gladys » gezeigt habe, ist es relativ einfach, ein Steuersystem in Node-RED zu erstellen. Die Ergebnisse können dann über Matter, MatterBridge oder MQTT an Gladys übertragen werden.
Aber lass uns zunächst einen anderen Weg erkunden. Werfen wir einen Blick auf Europa: Während der Franzose, ein Befürworter der Kernenergie, den Kopf schüttelt und der deutsche „Michel“ besorgt die Stirn runzelt, was passiert da eigentlich? Die Österreicher klettern seit Jahrzehnten die Berge hinauf und bestücken sie mit Balkon-Solaranlagen. Es gibt aber auch zahlreiche andere qualitativ hochwertige und erschwingliche Solarlösungen. Nehmen wir zum Beispiel das Unternehmen MyPV, das seit langem ein Heizelement in seinem Sortiment anbietet. Es heißt AC ELWA und ist steuerbar (das ist keine Werbung, nur ein Beispiel)…
Sehen wir uns also an, was wir damit machen können…
Dieser Heizwiderstand kann über eine HTTP-Anfrage gesteuert werden; mit anderen Worten, es reicht aus, Befehle an den Widerstand zu senden, wie man es mit einem Browser tun würde, und zu beobachten, was passiert. In Node-RED geschieht dies mit einem Knoten, der „http request“ genannt wird:
Was passiert, wenn wir genau diesen Befehl in einen Browser eingeben und ihn senden (der Heizstab gibt uns alle Informationen in Form eines XML-Dokuments zurück):
et genau dieser Eintrag „power“ interessiert uns. Der nächste Knoten ist also ein „XML-Knoten“, der den von der HTTP-Anfrage zurückgegebenen Wert korrekt formatiert:
Jetzt haben wir also die Daten in Node Red und wir müssen nur noch das richtige Datum mit dem « power » Wert auslesen, dies machen wir mit einem function Node und einer kleinen Funktion:
Wir haben also nun in unserem Flow in msg.payload den aktuellen Leistungswert des Widerstands. Hier passiert die Magie. In einer anderen Funktion gehen wir einfach wie folgt vor:
Wir sammeln systematisch die empfangenen Daten, wandeln sie in kWh um, fügen sie dem Stack hinzu und, wenn der interne Stack (2 Elemente) voll ist, gehen wir zum nächsten Schritt über. Mit anderen Worten: Der Stack enthält zwei Werte. Der gesamte Flow wird alle 15 Minuten gestartet (wir kommen gleich darauf zurück), sammelt zwei Werte und gibt alle 30 Minuten den kWh-Wert des Heizwiderstands zurück, also seine Leistung über einen Zeitraum von 30 Minuten.
Hier ist die Funktion:
// ***************************************************************
// Abfrage der aktuellen Messung
let watt = msg.payload;
if (watt === 2147483648) {
watt = 0;
}
// 1. Lesen der beiden Speicher
let messungen = flow.get(« solar_messungen ») || ;
// Holen Sie sich den aktuellen Gesamtzähler der Zähler (wichtig für Gladys)
let kwhGesamtzaehler = flow.get(« solar_kwh_gesamt ») || 0;
messungen.push(watt);
// 2. Prüfen, ob wir 2 Messungen gespeichert haben (30 min)
if (messungen.length >= 2) {
// Berechnung der beiden "Wh"-Blöcke (Watts × 0,25 Stunden)
let wh1 = messungen[0] * 0.25;
let wh2 = messungen[1] * 0.25;
// Verbrauch der letzten 30 Minuten in kWh
let kwh30Min = (wh1 + wh2) / 1000;
// Addieren des Verbrauchs zum Gesamtzähler
kwhGesamtzaehler += kwh30Min;
// Runden des Werts auf 3 Dezimalstellen
kwhGesamtzaehler = Math.round(kwhGesamtzaehler * 1000) / 1000;
// 3. Vorbereiten des Speichers für die nächsten 30 Minuten
flow.set("solar_messungen", []); // 15-Min-Messungen leeren
flow.set("solar_kwh_gesamt", kwhGesamtzaehler); // Gesamtzähler dauerhaft sichern
// 4. Nachricht an Gladys senden
msg.topic = "solar-wr/kwh-total";
msg.payload = {
wr_zaehler_kwh: kwhGesamtzaehler
}; // Gladys erhält den kumulierten Zählerstand
return msg;
} else {
// Wenn es sich um den ersten Messwert handelt, ihn im Speicher speichern
flow.set(« solar_messungen », messungen);
return null;
}
// ***********************************************************************
Hier ist, wo diese Funktion in den Flow eingebettet ist:
Wir beginnen damit, einen „inject“-Knoten hinzuzufügen und ihn so zu konfigurieren, dass er den Flow alle 15 Minuten auslöst, im Beispiel zwischen 10 Uhr und 20 Uhr täglich
Hier sind die Debug-Ausgaben. Er sammelt zwei Werte, dann sendet er die Daten:
Es bleibt nur noch, die Daten am Ende des Flows mit „mqtt out“ an MQTT zu senden, dann können wir endlich in Gladys weitermachen 
In Gladys benötigen wir das MQTT-Protokoll, das zugänglich sein muss:
Der Rest ist dann sehr einfach. Schritt 1: Erstellen eines virtuellen MQTT-Geräts:
Schritt 2: Wir fügen eine Energieverbrauchsüberwachungsfunktion hinzu:
Schritt 3: In den erweiterten Funktionen des Energiesensors weisen wir die Werte den MQTT-Subject-Daten zu.
Hier sind die Informationen, sie kommen also aus Node Red, letzte Funktion und gehen dann über MQTT nach Gladys:
Im Abschnitt „Energieüberwachung“ überprüfen Sie noch, ob das neue Energieüberwachungsgerät korrekt zugeordnet wurde:
Es bleibt nur noch, einen geeigneten Energiepreis auszuwählen und dann den Heizwiderstand als Zähler anzugeben.
Das war’s…
Fügen Sie dann eine Energieverfolgung im Dashboard hinzu und geben Sie den Heizwiderstand als Datenquelle an:
Das Ergebnis:
Ich danke allen, die mir geholfen haben, meine Anfängerprobleme zu überwinden. Wenn ihr einen Fehler findet, lasst es mich wissen. Wenn ihr eine Möglichkeit seht, die Dinge zu vereinfachen, lasst es mich wissen.
In diesem Tutorial habt ihr also eine Methode kennengelernt, um über eine HTTP-Anfrage einen lokalen Energiezähler abzufragen und dann ein geeignetes Energieverbrauchsüberwachungssystem in Gladys zu erstellen.
Viel Spaß, herzlichst, Thomas