Smartmeter mit Raspberry Pi und NodeRed
Im Sommer 2020 habe ich zu Hause eine Luft-Wärme Pumpe zusammen mit einer 4kW Photovoltaik Anlage bekommen.
In diesem Zuge habe ich vom Netzbetreiber zwei Digitale Stromzähler bekommen, welche den Stromverbrauch von der Heizung sowie den Gesamtstromverbrauch und den Einspeisestrom aufzeichnen.
Diese Digitale Stromzähler von der Firma ISKRAMeco besitzt eine optische digitale Schnittstelle, welche man auslesen kann.
Es wurde der Typ MT175 bei mir verbaut. Daher bezieht sich alles hier auf diesen Typ, kann aber leicht auf andere Typen adaptiert werden, da fast alle Stromzähler ähnlich funktionieren.
Im folgenden möchte ich dir zeigen wie man diesen mit einem Raspberry Pi aus liest und sich das auf einen Webserver anzeigen kann. So hat man immer den Stromverbrauch und die Kosten im Blick.
Jetzt mag der ein oder andere vielleicht sich fragen, warum ich das nicht einfach manuell ablese.
Nun das ist nicht so einfach.
Die beiden Stromzähler erfassen folgende Werte:
- Strom / Leistung was aus dem Netz entnommen wird
- Strom / Leistung was in das Netz eingespeist wird
- Strom / Leistung was die Heizung benötigt (Heizstrom)
Nun kann man anhand der Werte alles berechnen, aber man sieht nicht, wie viel man von der eigenen PV Anlage selbst verbraucht hat. Auch sieht man nicht direkt den eigenen Stromverbrauch an. Da dieser sich aus Gesamtstromverbrauch – Heizstrom zusammen setzt.
Um es einfach ablesen und Protokollieren zu können habe ich mir eben diese System gebastelt.
Inhaltsverzeichnis
- Welche Komponenten sind im Einsatz
- Verkabelung
- Installation des Betriebssystems für den Raspberry PI
- Raspberry PI konfigurieren und NodeRed installieren
- NodeRed
- Neue Funktionen NodeRed hinzufügen
- NodeRed Programm
- NodeRed Webside Oberfläche
- Links und Downloads
Welche Komponenten sind im Einsatz:
- 2 Stück ISKRA MT175 Stromzähler
- 2 Stück IR (Infrarot) Schreib/Lesekopf USB von Weidmann Elektronik >link
- 1 Stück Raspberry Pi 4 B, 4x 1,5 GHz >link
- 1 Stück MeanWell Hutschienen Netzteil 5V/15W Typ: HDR-30-5 >link
- 1 Stück USB-C (M) bis 2 pin USB Header Kabel >link
- 1 Stück Raspberry Pi 4 Hutschienen Gehäuse >link
- 1 Stück MicroSD Karte 16GB >link
Außerdem sind bei mir noch verwendet:
- für Photovoltaik Anlage einen Umrichter von SMA STP5.0-3AV-40-BS >link
Hinweis:
Los Gehts:
Die Verkabelung sollte relativ einfach von statten gehen.
Zu aller erst sollte im Schaltschrank des Hauses das Meanwell 5V Netzteil von einem Fachmann angeschlossen und mit einer eigenen Sicherung ausgestattet werden.
Danach kann der RaspberryPi in das Hutschienengehäuse eingebaut werden.
Anschließend kann man das USB Kabel mit dem Netzteil und dem Raspberry Pi verbinden (Auf Polung achten!)
bevor man den Raspberry Pi mit Spannung muss erst noch die beiden Leseköpfe an den Stromzählern angebracht und mit dem Raspberry Pi verbunden werden.
Danach müssen wir erst auf die SD Karte das Betriebssystem installieren.
so schaut bei mir der Aufbau um Schrank aus.
Installation des Betriebssystems für den Raspberry PI
zu aller erst musst du dir das aktuelle Raspberry Pi Betriebssystem Raspbian auf der Homepage von Raspberry Pi herunter laden.
Es gibt hier drei Versionen. Es funktionieren generell alle 3, ich habe die „Vollversion“ wo der Desktop und einige Software schon dabei ist verwendet.
Möchte man kein Desktop ist die Lite Version ideal, da diese Version sehr schlank und performant ist.
Anschließend muss man sich noch Win32Diskimager herunter laden und installieren. Damit spielt man das Betriebssystem auf die SD Karte auf.
Man steckt die SD Karte in den Kartenlesers des PCs.
Anschließend startest du WIN32 Disk Imager, wählst bei „Image File“ die Betriebssystem Datei aus, guckst dass bei „Device“ das Laufwerk zur richtigen SD Karte drin steht und anschließend klickst du auf „Write“. Nun kann es mehrere Minuten dauern bis der Prozess abgeschlossen ist.
Bevor man die SD Karte in den Raspberry Pi steckt müssen wir noch eine Kleinigkeit konfigurieren, sodass der RaspberryPi sich automatisch mit dem WLan verbindet und auch via SSH angesteuert werden kann.
Hierzu öffnest du den Windows Editor.
dort gibst du folgenden Text ein und speicherst die Datei direkt im Hauptverzeichnis der SD Karte (Einfach aufs Laufwerk z.B. im Laufwerk X:\) unter dem Namen „wpa_supplicant.conf“ ab.
country=DE
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
ap_scan=1
network={
scan_ssid=1
ssid="wlanname"
psk="unserpasswort"
key_mgmt=WPA-PSK
} Wichtig ist dass du natürlich im Text der Datei unter „WLANNAME“ dein WLan Name / SSID eingibst
Und unter „UnserPasswort“ das WLan Passwort.
Damit der SSH Server automatisch gestartet wird legst du eine leere Datei auf dem Hauptverzeichnis mit dem Namen „ssh “ ohne Dateiendung an. (Kannst du ebenfalls mit dem Editor machen).
Nun kannst du die SD Karte aus Windows auswerfen und sie in den RaspberrPi stecken.
Raspberry Pi konfigurieren und NodeRed installieren
Nachdem du die SD Karte in den Raspberry Pi gesteckt hast, kannst du diesen mit Spannung versorgen.
Nun wird dieser Booten und die grüne LED auf dem RaspberryPi wird flackern.
Nach einigen Sekunden kannst du über die Oberfläche deines Rooters dir die IP Adresse des Raspberry Pi anzeigen lassen.
Diese bitte gut notieren.
Als nächstes verbindest du dich mit dem RaspberryPi über das Program Putty.
Hierzu einfach die IP Adresse bei „Host Name“ eingeben und auf „Open“ klicken.
Nun sollte sich ein schwarzes Fenster öffnen. Hier gibst du nun einmal den Benutzernamen pi und das passwort raspberry ein.
nun müssen wir einige Einstellungen vornehmen.
Gebe hierzu folgenden Text in das Fenster ein: „sudo raspi-config“ und klicke Enter.
Danach öffnet sich folgendes Menü:
Mit den Pfeiltasten und Enter kann man hier navigieren.
als erstes gehst du auf „7. Advanced Options“ dort dann auf „A1 Expand Filesystem“. Danach folgst du dem Menü. Hiermit wird die komplette SD Karte vom RaspberryPi genutzt und nicht nur die ersten paar GB Speicher.
Danach solltest du in der raspi-config bei „1 Change passworD“ das Standardpasswort ändern und merken / aufschreiben.
Unter „4 Localisation Options“ kannst du auf Wunsch den „Standort“ ändern und somit die Zeitzone und das Tastaturlayout auf Deutsch umstellen. Folge hierzu einfach dem Menü.
Unter „2 Network Options“ kannst du den Hostnamen vom Raspberry Pi ändern. Bei mir z.B. „Smartmeter“ und du kannst hier auch nochmal ggf. die WLAN Einstellungen ändern, falls nötig.
Wenn alles eingestellt ist gehts wieder zurück zum schwarzen Hauptfenster von Putty
Nun musst du den RaspberryPi auf den neusten Stand bringen. Hierzu gibst du folgende zwei Befehle nacheinander ein (nicht wundern, es kann mehrere Minuten dauern am Anfang, bis alle updates installiert sind).
sudo apt-get update
sudo apt-get upgrade
Nun können wir NodeRed installieren und konfigurieren:
NodeRed ist eine grafische Programmiersprache, welche auch für Anfänger sehr leicht zu bedienen ist und einen Webserver integriert hat. Damit lässt sich solch ein Projekt wie wir es vor haben ganz leicht umsetzen.
Um NodeRed zu installieren gibst du folgenden Befehl ein:
bash <(curl -sL https://raw.githubusercontent.com/node-red/raspbian-deb-package/master/resources/update-nodejs-and-nodered)
damit NodeRed und dessen Serverdienst bei jedem Start von RaspberryPi automatisch startet musst du folgenden Befehl eingeben.
sudo systemctl enable nodered.service
mit den folgenden Befehlen lässt sich NodeRed manuell starten, stoppen, neustarten oder dessen Status abfragen:
sudo systemctl start nodered.service sudo systemctl stop nodered.service sudo systemctl restart nodered.service sudo systemctl status nodered.service
NodeRed
nun ist alles Bereit um mit NodeRed zu arbeiten.
Gehe in deinen Internetexplorer und gib dort die IP deines RaspberryPi ein gefolgt mit dem Port 1880.
zum Beispiel wie folgt:
http://192.168.1.181:1880
Nun öffnet sich eine grafische Oberfläche die in etwa wie folgt ausschaut:
Auf der Linken Seite befinden sich die ganzen Nodes. Das sind praktisch die Befehle und Funktionen.
Diese lassen sich einfach von links in das Fenster in die Mitte ziehen. Rechts befinden sich die Eigenschaftsfenster sowie das Debugging etc.
Oben Rechts befindet sich der „Speichern“ Button „deploy“. Sobald dieser Rot dargestellt ist hast du etwas am Programm verändert und kannst es darüber speichern und sofort ausführen.
In der Mitte Oben kann man verschiedene Reiter anlegen. So kann man das Programm übersichtlicher gestalten und auch in verschiedene Bereiche aufteilen und auch Unterprogramme anlegen.
Ganz Rechts oben befindet sich das Optionsmenü. Hier kann man sein Programm Exportieren und dadurch auf dem Desktop Sichern, oder ein Program importieren oder Benutzereinstellungen vornehmen.
Außerdem kann man mit „Palette verwalten“ neue Funktionen aus dem Internet herunter laden und installieren oder eben auch vorhandene löschen.
Dies wirst du nun als erstes tun.
Neue Funktionen NodeRed hinzufügen
Wir benötigen für unser Projekt einige neue Funktionen, welche uns ermöglichen die Schnittstelle der Stromzähler sowie den Umrichter von SMA auszulesen.
Hierzu gehst du oben im Menü auf „Palette verwalten“. Nun öffnet sich folgendes Fenster.
Danach musst du nacheinander folgende Pakete installieren. Einfach im Reiter „Installieren“ oben in die Suche eingeben.
node-red-contrib-smartmeter
node-red-contrib-ui-led
- node-red-dashboard
- node-red-node-pi-gpio
- node-red-node-serialport
- node-red-contrib-sma-webconnect
- node-red-contrib-dwd-local-weather
- node-red-contrib-dwd
- node-red-contrib-date-converter
Wenn alles installiert ist kannst du mit dem Aufbau des Programms starten.
Als Vorlage sind im folgenden einige Screenshots dargestellt.
Einfach genau so umsetzen.
Alernativ kannst du weiter unten das fertige Programm auch herunterladen und über die Importfunktion importieren.
Du musst allerdings dann noch ein paar Einstellungen (IP Adresse etc.) abändern.
NodeRed Programm
Flows Überblick
Zu aller erst benötigen wir 4 Flows (Tabs).
Diese legst du an indem du oben über dem Programmierfenster auf das Plus Zeichen glickst. Benenne diese dann entsprechend um.
Ich habe sie wie folgt benannt:
- Stromzähler auslesen
- PV Anlage
- Wetterstation DWD
- Preise
Flow Stromzähler
In dem Flow „Stromzähler auslesen“ kommen die in den folgenden beiden Bildern ersichtlichen Funktionen rein.
Anhand der Symbole findest du diese ganz gut links im Auswahlmenü. Einfach rüber schieben und entsprechend plazieren.
Anschließend verbinden und umbenennen.
Die Dunkelgrünen Funktionen sind Debug Funktionen und werden nur für das Testen und Debugen benötigt. Wenn neben der Debug Funktion rechts das Viereck voll ausgefüllt ist, dann ist das Element aktiv.
Die Funktion "Zähler Z1 formatieren" sollte wie im Bild links ausschauen. Den Code gibt es unten nochmal direkt zum kopieren.
Eine kuzre Erklärung hierzu:
Mit var wird eine Variable definiert.
Der Variable "StromZ1" wird die Nachicht aus dem Stromzähler übergeben und zwar nur aus der entsprechenden Array Tabelle.
Mit "global.get" werden Werte aus globalen Variablen gelesen.
Mit "global.set" wird ein Wert in eine globale Variable gespeichert. Wenn diese noch nicht existiert wird sie automatisch angelegt.
Mit "return" werden Werte aus der Funktion ausgegeben.
var StromZ1 = msg.payload["1-0:1.8.0*255"].values[0].value;
var DatumUrsprung=global.get('DatumUrsprung');
var VZahlerstandZ1=global.get('VZahlerstandZ1');
var VZahlerstandZ2V=global.get('VZahlerstandZ2V');
var VZahlerstandZ2E=global.get('VZahlerstandZ2E');
var StromverbrauchZeitZ1=0;
global.set('Z1',StromZ1);
StromverbrauchZeitZ1 = StromZ1 - VZahlerstandZ1;
global.set('StromverbrauchZeitZ1',StromverbrauchZeitZ1);
return [
{payloadZ1:StromZ1},
{payloadZ1:StromverbrauchZeitZ1}
]
In der Funktion "Smartmeter Z1" müssen folgende Einstellungen übernommen werden.
Falls du weitere USB Geräte installiert hast, kann es sein, dass "ttyUSB0" anders lauten muss. "ttyUSB1" oder "ttyUSB2" etc.
Wenn du den von mir verlinkten Lesekopf verwendest dann bitte das SMiProtocol verwenden. Ansonsten musst du schauen, welches Protokoll passt.
Bei Request Intervall kannst du Einstellen wie oft der Digitale Stromsensor ausgelesen werden soll. Bei mir alle 300 Sekunden.
In der Funktion "Smartmeter Z2" müssen folgende Einstellungen übernommen werden.
Falls du weitere USB Geräte installiert hast, kann es sein, dass "ttyUSB1" anders lauten muss. "ttyUSB2" oder "ttyUSB3" etc.
Wenn du den von mir verlinkten Lesekopf verwendest dann bitte das SMiProtocol verwenden. Ansonsten musst du schauen, welches Protokoll passt.
Bei Request Intervall kannst du Einstellen wie oft der Digitale Stromsensor ausgelesen werden soll. Bei mir alle 300 Sekunden.
Bei der Textausgabe "Zählerstand Z1" werden folgende Einstellungen übernommen. Genauso verläuft es sich mit den anderen Ausgaben.
Oben bei Group wird die Gruppe zugeordnet wo der Text später auf der Weboberfläche angezeigt werden soll.
Label ist der Name, was vor dem Wert stehen soll
Value format ist die Variable bzw. die Message die ausgegeben werden soll. Hinter den Klammern kann man noch einen beliebigen Standardtext anhängen.
Layout: Hier kann man verschiedene Layouts auswählen. Einfach mal probieren
Im folgenden sind die Quelltexte der weiteren Funktionen aufgelistet. Überschrift = Funktion und kommt nicht in die Funktion! Die Reihenfolge entspricht dem Bild oben!
"Stromkosten"
var payloadZ1=msg.payloadZ1;
var VStromEuro=global.get('VStromEuro');
var StromverbrauchZeitZ1 =global.get('StromverbrauchZeitZ1');
var StromverbrauchZeitZ2V =global.get('StromverbrauchZeitZ2V');
var StromverbrauchZeitZ2E =global.get('StromverbrauchZeitZ2E');
var Ergebnis=0;
Ergebnis = VStromEuro * StromverbrauchZeitZ1;
return [
{payload:Ergebnis},
]
"Stromverbrauch Wärmepumpe"
var payloadZ1=global.get('Z1');
var payloadZ2=global.get('Z2A');
var StromverbrauchZeitZ1 =global.get('StromverbrauchZeitZ1');
var StromverbrauchZeitZ2V =global.get('StromverbrauchZeitZ2V');
var StromverbrauchZeitZ2E =global.get('StromverbrauchZeitZ2E');
var Ergebnis=0;
Ergebnis = StromverbrauchZeitZ2V - StromverbrauchZeitZ1;
return [
{payload:Ergebnis},
]
"Heizkosten"
var payloadZ1=msg.payload;
var HStromEuro=global.get('HStromEuro');
var Ergebnis=0;
Ergebnis = HStromEuro * payloadZ1;
Ergebnis = Math.round(Ergebnis*100)/100;
return [
{payload:Ergebnis},
]
"Eigenverbrauch PV Strom"
var payloadPV=global.get('PV');
var payloadZ2=global.get('Z2E');
var StromverbrauchZeitZ1 =global.get('StromverbrauchZeitZ1');
var StromverbrauchZeitZ2V =global.get('StromverbrauchZeitZ2V');
var StromverbrauchZeitZ2E =global.get('StromverbrauchZeitZ2E');
var Ergebnis=0;
Ergebnis = payloadPV - payloadZ2;
return [
{payload:Ergebnis},
]
"Zähler Z2 formatieren"
var StromZ2A = msg.payload["1-0:1.8.0*255"].values[0].value;
var StromZ2E = msg.payload["1-0:2.8.0*255"].values[0].value;
var DatumUrsprung=global.get('DatumUrsprung');
var VZahlerstandZ1=global.get('VZahlerstandZ1');
var VZahlerstandZ2V=global.get('VZahlerstandZ2V');
var VZahlerstandZ2E=global.get('VZahlerstandZ2E');
var StromverbrauchZeitZ2V=0;
var StromverbrauchZeitZ2E=0;
global.set('Z2A',StromZ2A);
global.set('Z2E',StromZ2E);
StromverbrauchZeitZ2V = StromZ2A - VZahlerstandZ2V;
StromverbrauchZeitZ2E = StromZ2E - VZahlerstandZ2E;
global.set('StromverbrauchZeitZ2V',StromverbrauchZeitZ2V);
global.set('StromverbrauchZeitZ2E',StromverbrauchZeitZ2E);
return [
{payloadZ2A:StromZ2A},
{payloadZ2E:StromZ2E},
{payloadZ2A:StromverbrauchZeitZ2V},
{payloadZ2E:StromverbrauchZeitZ2E}
]
"Vergütung PV"
var payloadZ2E=msg.payloadZ2E;
var PVStromEuro=global.get('PVStromEuro');
var Ergebnis=0;
Ergebnis = PVStromEuro * payloadZ2E;
Ergebnis = Math.round(Ergebnis*100)/100;
return [
{payload:Ergebnis},
]
"Ersparnis Ges"
var payloadPV=global.get('PV');
var payloadZ2E=global.get('Z2E');
var PVStromEuro=global.get('PVStromEuro');
var VStromEuro=global.get('VStromEuro');
var HStromEuro=global.get('HStromEuro');
var StromverbrauchZeitZ1 =global.get('StromverbrauchZeitZ1');
var StromverbrauchZeitZ2V =global.get('StromverbrauchZeitZ2V');
var StromverbrauchZeitZ2E =global.get('StromverbrauchZeitZ2E');
var Ergebnis=0;
var ErgebnisEigenverbrauch=0;
var ErgebnisErsparnis=0;
var ErgebnisVergutung=0;
ErgebnisEigenverbrauch = payloadPV - payloadZ2E;
ErgebnisErsparnis = ErgebnisEigenverbrauch * VStromEuro;
ErgebnisVergutung = payloadZ2E * PVStromEuro;
Ergebnis = ErgebnisVergutung + ErgebnisErsparnis;
//Ergebnis = ErgebnisErsparnis;
//Ergebnis = ErgebnisVergütung;
Ergebnis = Math.round(Ergebnis*100)/100;
return [
{payload:Ergebnis},
]
"Datum"
var DatumUrsprung = global.get('DatumUrsprung');
return [
{payload:DatumUrsprung},
]
Flow PV Anlage
In dem Flow „PV Anlage“ kommen die in den folgenden beiden Bildern ersichtlichen Funktionen rein.
Bei der Funktion "Sma-webconnect", das mit dem Welt Symbol und der IP Adresse im Namen, werden folgende Einstellungen übernommen:
IP Adresse = IP Adresse deines SMA Wechselrichter
User Group = User
Password = Vergebenes Passwort der Wechselrichter Oberfläche
Device = SB Tripower, wenn es SB Tripower ist,
Diese Funktion verbindet sich auf die Webconnect Oberfläche des Umrichters und zieht sich dort direkt aus dem Hinterrund die benötigten Daten raus. Deswegen muss man direkt das Passwort der Webconnect Oberfläche angeben. Man kann diese Node Funktion noch beliebig anpassen und weitere Devices hinzufügen. Dies möchte ich hier aber nicht erklären.
Für weitere Informationen bitte direkt an die verlinkte github Page des Entwicklers wenden.
Die Funktionen "gauge" geben Werte als Tarroanzeiger auf der Weboberfläche aus. Dies verwenden wir um den aktuellen Strom welcher von der PV Anlage erzeugt wird Grafisch darzustellen.
Unter "Group" wählen wir aus in welcher Gruppe auf der Weboberfläche die Grafik angezeigt werden soll.
Unter "Type" kannst du verschiedene Typen wählen. einfach mal testen.
Unter "Label" gibst du die Bezeichnung an.
Unter "Value Format" gibst du an welche Nachricht bzw. Variable angezeigt werden soll. Hinter den Klammern kannst du noch einen freien Text hinzufügen. In meinem Fall die Einheit.
Unter "Units" wird die Einheit angegeben
Unter "Range" gibst du den Bereich an von wo bis wo der Tarro anzeigen soll. Ich habe von 0 bis 4100 gewählt weil meine PV Anlage nur max. 4000Watt bringen kann.
Unter Colour kannst du die Farben wählen. Es gibt einen Übergang zwischen den Farben, bei wenig wird Gelb angezeigt, Mitte, Orange und rechts Rot. Einfach hier auch etwas ausprobieren.
Im folgenden sind die Quelltexte der weiteren Funktionen aufgelistet. Überschrift = Funktion und kommt nicht in die Funktion! Die Reihenfolge entspricht dem Bild oben!
"PVWechselrichter-WertFormatieren"
var StromPV = msg.payload.Ertrag;
StromPV = Math.round(StromPV);
global.set('PV',StromPV);
StromPV = global.get('PV');
return [
{payloadPV:StromPV}
]
"ModbusTCP-WertFormatieren"
var msg1 = {payload:"totalErzeugung"};
var TCPEingang = parseInt(msg.payload[0]*0x1000 + msg.payload[1]);
if (TCPEingang >= 0) {
msg1.payload = TCPEingang.toString();
}
else msg1=null;
return [msg1];
"Funktion"
var StromPV = msg.payload;
global.set('PV',StromPV);
StromPV = global.get('PV');
return [
{payloadPV:StromPV},
]
"ModbusTCP-WertFormatieren"
var msg1 = {payload:"totalErzeugungTag"};
//var TCPEingang = parseInt(msg.payload[4]*0x1000 + msg.payload[5]);
var TCPEingang = parseInt(msg.payload[4]);
if (TCPEingang >= 0) {
msg1.payload = TCPEingang.toString();
}
else msg1=null;
return [msg1];
"Funktion"
var StromPV = msg.payload;
//global.set('PV',StromPV);
//StromPV = global.get('PV');
return [
{payloadPV:StromPV},
]
Flow Wetterstation DWD
In dem Flow „Wetterstation DWD“ kommen die in den folgenden beiden Bildern ersichtlichen Funktionen rein.
Die Funktion "DWDWeather" ruft immer wenn der timestamp abgelaufen ist das aktuelle Wetter beim Deutschen Wetterdienst bzw. bei der jeweiligen Station ab.
Unter MOSMIX Station gibst du die gewünschte Wetterstation ID ein. Eine Liste findest du in dem Link unter der Eingabe ("here").
Unter "Loock ahead hours" gibst du die Stunden ein inwieweit in die Zukunft geschaut werden soll. In der oberen Node Funktion ist es 0 in der unteren 23 .
Die restlichen Felder kannst du leer lassen.
Im folgenden sind die Quelltexte der weiteren Funktionen aufgelistet. Überschrift = Funktion und kommt nicht in die Funktion! Die Reihenfolge entspricht dem Bild oben!
"Wetter 1"
return [
{payload:msg.payload.station},
{payload:msg.payload.tempc},
{payload:msg.payload.humidity},
{payload:msg.payload.windspeed},
{payload:msg.payload.winddirection},
{payload:msg.payload.precipitation_perc},
{payload:msg.payload.precipitationNext24h},
{payload:msg.payload.forecast_dt},
{payload:msg.payload.precipitation_perc}
]
"Wetter 2"
return [
{payload:msg.payload.station},
{payload:msg.payload.tempc},
{payload:msg.payload.humidity},
{payload:msg.payload.windspeed},
{payload:msg.payload.winddirection},
{payload:msg.payload.precipitation_perc},
{payload:msg.payload.precipitationNext24h},
{payload:msg.payload.forecast_dt},
{payload:msg.payload.precipitation_perc}
]
"DWD"
return [
{payload:msg.warnings[0].regionName},
{payload:msg.warnings[0].end},
{payload:msg.warnings[0].start},
{payload:msg.warnings[0].type},
{payload:msg.warnings[0].state},
{payload:msg.warnings[0].level},
{payload:msg.warnings[0].description},
{payload:msg.warnings[0].event},
{payload:msg.warnings[0].headline},
{payload:msg.warnings[0].instruction},
{payload:msg.warnings[0].stateShort}
]
Flow Preise
In dem Flow „Preise“ kommen die in dem folgenden Bild ersichtlichen Funktionen rein.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.
Im folgenden sind die Quelltexte der weiteren Funktionen aufgelistet. Überschrift = Funktion und kommt nicht in die Funktion! Die Reihenfolge entspricht dem Bild oben!
"Funktion 1"
var VStromEuro = msg.payload/100;
global.set('VStromEuro',VStromEuro);
StromPV = global.get('VStromEuro');
return [
{payloadVStromEuro:VStromEuro},
]
"Funktion 2"
var HStromEuro = msg.payload/100;
global.set('HStromEuro',HStromEuro);
StromPV = global.get('HStromEuro');
return [
{payloadHStromEuro:HStromEuro},
]
"Funktion 3"
var PVStromEuro = msg.payload/100;
global.set('PVStromEuro',PVStromEuro);
StromPV = global.get('PVStromEuro');
return [
{payloadPVStromEuro:PVStromEuro},
]
"Funktion 4"
var DatumUrsprung = msg.payload;
global.set('DatumUrsprung',DatumUrsprung);
DatumUrsprung = global.get('DatumUrsprung');
return [
{payloadVStromEuro:DatumUrsprung},
]
"Funktion 5"
var VZahlerstandZ1 = msg.payload;
global.set('VZahlerstandZ1',VZahlerstandZ1);
VZahlerstandZ1 = global.get('VZahlerstandZ1');
return [
{payloadVStromEuro:VZahlerstandZ1},
]
"Funktion 6"
var VZahlerstandZ2V = msg.payload;
global.set('VZahlerstandZ2V',VZahlerstandZ2V);
VZahlerstandZ2V = global.get('VZahlerstandZ2V');
return [
{payloadVStromEuro:VZahlerstandZ2V},
]
"Funktion 7"
var VZahlerstandZ2E = msg.payload;
global.set('VZahlerstandZ2E',VZahlerstandZ2E);
VZahlerstandZ2E = global.get('VZahlerstandZ2E');
return [
{payloadVStromEuro:VZahlerstandZ2E},
]
NodeRed Webside Oberfläche
Durch die Installation der Funktion „node-red-dashboard“ hast du die Oberfläche für die Website zu NodeRed hinzugefügt. Über das Dashboard kannst du alle Werte grafisch anzeigen lassen und dir eine kleine Homepage basteln.
Diese Homepage erreichst du unter folgenden Link:
http://IPRaspberry:1880/ui/
Du kannst die Farben und Anordnungen individuell anpassen. Im folgenden möchte ich beschreiben wie das geht.
In NodeRed kannst du rechts im Menü auf das im nebenstehenden Bild eingekreisten Symbol klicken. Darüber gelangst du in das Einstellmenü vom Dashboard.
Auf dem Reiter „Layout“ kannst du die einzelnen Seiten anlegen und ihnen einzelne Gruppen zuordnen. Diesen Gruppen werden dann die Graphen und Texte und Eingabefelder zugeordnet.
Wenn du mit dem Kursor über die Seite gehst kommen mehre kleine Symbole.
Über „Layout“ kannst du dann die Gruppen individuell anordnen. Das ist eigentlich selbsterklärend.
Auf dem Reiter „Site“ kannst du den Namen deiner Website und weitere Einstellungen vornehmen.
Auf dem Reiter Theme kannst du die ganzen Farben anpassen. Hier einfach mal etwas rumspielen.
Wichtig: Nach jeder Änderung auf „deploy“ klicken um diese zu übernehmen.
Und so sieht die Bewoberfläche bei mir aus:
In der Übersicht, werden alle relevanten Werte übersichtlich dargestellt. Die aktuelle PV Leistung wird als Tarro Graph angezeigt.
Auf der Seite „Stromzähler“ werden die abgelesenen Stromstände der einzelnen Zähler und des PV Umrichters angezeigt und die daraus resultierenden Stromverbrauche sowie Kosten.
Auf der Seite „Preise und Einstellungen“ können die Stromverbrauchspreise und die Einspeisevergütung eingetragen werden. Außerem kann zum Jahresanfang der letzte Zählerstand eingegeben werden, sodass immer der Jahresstromverbrauch ersichtlich ist.
Links und Downloads:
Zum Schluss noch im folgenden ein paar Links, die dir ebenfalls weiterhelfen könnten.
Außerdem noch von mir ein paar Downloads:
Downloads:
- NodeRed Programm >Link
Bitte mit rechter Maustaste auf den Link klicken und dann auf „Ziel Speichern unter“ gehen.
Links:
- Seite wo einiges über digitale Stromzähler und deren Schnittstellen zu finden ist. Auch Anleitungen wie man sich Auslesegeräte selbst baut.
https://wiki.volkszaehler.org/hardware/controllers/ir-schreib-lesekopf-pi-ausgang - Forumsbeitrag zum SMA Wechselrichter auslesen mit NodeRed:
https://forum.iobroker.net/topic/1100/sma-wechselrichter/2 - NodeRed Homepage und Flows zum suchen und leichter Finden inkl. deren Beschreibung und vielen Tutorials
https://flows.nodered.org/ - einen Blog Beitrag von Stefan Weigert zum Thema SML Interface von Digitalen Stromsensoren
http://www.stefan-weigert.de/php_loader/sml.php
Neueste Kommentare