Als Besitzer einer PV-Anlage ist es natürlich sehr interessant die Live-Daten der Anlage in Echtzeit in meiner Fibaro-Hausautomatisierung einzubinden.Wie das geht, erfährst du hier:
Fibaro VD - Livedaten des SMA Wechselrichter
Da ich mir eine PV-Anlage mit einem SMA Wechselrichter zugelegt habe erläutere ich das Vorgehen hier für die Anbindung an den Modbus meines SMA Sunny Tripower 7000TL-20 Wechselrichters. Bei anderen Wechselrichter-Anbietern wird das aber sehr ähnlich sein! Das Skript kann natürlich auch der erste Schritt sein um andere Programme damit zu basteln. Man könnte z.B. die Beschattung aufgrund der Sonneneinstrahlung steuern, oder Geräte wie z.B. eine Waschmaschine dann ersten starten wenn die Eigenproduktion an Strom ausreicht um sie kostenlos zu betreiben…
[alert variation="alert-warning"]ACHTUNG: Im folgenden erhaltet ihr Informationen über PV-Technik, Steuerungen, Elektrotechnik, Anwendungen, Schnittstellen usw. Die Informationen sind so gehalten, dass auch technische Laien zurechtkommen werden. Wir verweisen jedoch sicherheitshalber darauf, dass alle Eingriffe in die Elektrik, PV-Anlage, Arbeiten an Steuerungen, an Stromkreisen usw. durch eine Elektrofachkraft zu erfolgen haben. Diese Erläuterung soll also nur zum allgemeinen Verständnis beitragen. Das Befolgen der Erläuterung erfolgt ausschließlich auf eigene Gefahr![/alert]Modbus am SMA Sunny Tripower aktivieren
SMA öffnete sich 2015 für Drittanbieter und stattet seit dem Wechselrichter mit der Modbus-Protokoll-Schnittstelle aus. Weitere Infos dazu hier:
https://www.sma-sunny.com/jetzt-moeglich-integration-von-sma-geraeten-durch-modbus/
Welche SMA Wechselrichter unterstützen überhaupt Modbus?
https://www.sma-sunny.com/servicetipp-welche-sma-wechselrichter-unterstuetzen-modbus-2/
An meinem SMA Sunny Tripower 7000TL-20 Wechselrichter kann man ab Firmware Version 2.55.03.R vom Oktober 2016 die Modbus-Protokoll-Schnittstelle nutzen. Über die Schnittstelle kann der Wechselrichter abgefragt werden um so z.B. Informationen wie Energie und Leistung zu erhalten. Diese Funktion war bisher nicht verfügbar. Evtl. müsst ihr ein Firmwareupdate durchführen sofern ihr noch eine ältere Firmwareversion habt.
https://www.sma.de/service/downloads.html
Hier die Anleitung zum Firmwareupdate mit SD-Karte:
http://files.sma.de/dl/1348/NG_UpdSD-TB-de-32.pdf
Über das Programm Sunny Explorer von SMA kann man den Modbus aktivieren.
http://files.sma.de/dl/8494/SunnyExplorerSetup_v1_07_29_R.exe
Dazu muss man sich als Installateur einloggen. Im Reiter “Einstellungen” findet man unter „Anlagenkommunikation” zunächst die Einstellungen für die Speedwire (TCP/IP) Verbindung:
SMA Sunny Explorer- IP Adresse auslesen
Hier empfiehlt es sich die automatische Konfiguration (DHCP) mit „Nein“ anzuwählen, bzw. auszuschalten und eine feste IP-Adresse einzugeben damit Fibaro eine eindeutige gleichbleibende Adresse zur Verfügung hat. Die IP-Adresse müsst Ihr anhand eures eigenen Netzwerkes anpassen. Sie wird höchstwahrscheinlich von meinen Werten (192.168.178.6) abweichen! Diese bitte merken!
Kommunikation mit dem Wechselrichter
Unter „Externe Kommunikation“ aktiviert man nun den Modbus:
SMA Sunny Explorer - Externe Kommunikation des Wechselrichter
Merkt euch nun auch den „Port“ und die „Unit ID“! Es kann sein, dass ihr nun den Wechselrichter neu starten müsst. Dies macht ihr am Besten nachts, wenn keine Sonne scheint und somit keine Last auf dem System ist!
Modbus Verbindungstest
Nun könnt ihr die Verbindung zu eurem Wechselrichter testen. Dazu braucht ihr das Tool „Modbus Master Sim“ von Radzio, welches ihr hier runterladen könnt:
http://www.protoconvert.com/SoftwareTools/Modbus/ModbusMasterSimulator.aspx
Nun bei „Connection Settings“ als Protokoll „Modbus TCP“ wählen und dieselbe IP-Adresse und Port verwenden die ihr Abschnitt 1 „Modbus am SMA Sunny Tripower aktivieren“ im Sunny Explorer eingestellt habt.
Modbus Master
Des Weiteren könnt ihr im Modbus Master Sim über „New“ folgende Parameter eingeben:
- IP Adress: Wie oben bereits festgelegt, entsprechend eurer eigenen Netzwerkeinstellungen!
- TCP Port: Wie oben bereits festgelegt! Z.B. 502
- Device ID: Wenn ihr in eurem SMA Wechselrichter einen original SMA Modbus verbaut habt ist die Unit ID = 3 bzw. die im letzten Schritt gemerkte Unit ID! Sollte es ein SunSpec Modbus sein, so ist die Unit ID wahrscheinlich = 126.
- Address: Wir wollen hier beispielhaft die „Geräteklasse“ abfragen.
Die steht im Register 30051! - Holding Register auswählen (les- und schreibbar).
Modbus Master
Nachdem ihr das Register abgefragt habt, erhaltet ihr die Antwort wie oben im Beispiel.
- Register: 30051 (-> Abfrage = Geräteklasse)
- Antwort: 8001 (-> Ausgabewert = Solar Wechselrichter)
Der Test sollte erfolgreich sein bevor ihr hier weiterlest!
Import des virtuellen Modules in Fibaro
Das virtuelle Modul kann hier heruntergeladen werden: VD FIBARO SMA Modus
Die Zip-Datei enthält das virtuelle Modul: „PV_Stromerzeugung.vfib“
Außerdem befinden sich noch einige Symbole im PNG-Format anbei die später grafisch die Leistung darstellen sollen. Alles muss in ein beliebiges Verzeichnis extrahiert werden.
Danach muss das virtuelle Modul in Fibaro importiert werden.
Fibaro Oberfläche - Import virtual Device
Modulkonfiguration
Anschließend müsst ihr im virtuellen Modul „PV Stromerzeugung“ dieselbe IP-Adresse und Port verwenden die ihr im Sunny Explorer eingestellt habt! Siehe dazu Abschnitt 1 „Modbus am SMA Sunny Tripower aktivieren“ dieser Beschreibung.
Anpassungen - Konfiguration des virtual Device
Symbole für das virtuelle Modul einrichten
Als nächstes müssen die Symbole alle in Fibaro eingefügt werden. Dazu auf „Symbol ändern“ klicken. Danach jedes Symbol einzeln hinzufügen! Nach dem Upload kommt ein wesentlicher Schritt den ich allerdings nur in Firefox erklären kann, da ich ausschließlich diesen Browser verwende. Bei anderen Browsern wird dies aber bestimmt ähnlich funktionieren. Ihr klickt nun mit der rechten Maustaste auf eines der Symbole. Nun erscheint im Menü der Punkt „Grafik-Info anzeigen“ welchen Ihr auswählt. Im folgenden Dialogfenster müsst Ihr nun alle Symbole einzeln anwählen und die Dateinamen anschauen.
Symbole dem VD zuweisen
Das erste hinzugefügte Bild heißt nun bei mir „User1001.png“. Bei euch wird es anders heißen. Wichtig ist die Nummer, hier bei mir eben: „1001“. Die brauchen wir später um die Bilder im LUA-Code auswählen zu können. Notiert euch nun alle Nummern zu den entsprechenden Symbolen.
- Erstes Bild: „User1001.png“ und somit: 1001
- Zweites Bild: „User1002.png“ und somit: 1002
usw., bis zum letzten (elften) Bild!
Virtuelles Modul anpassen (Einstellungen)
Im nächsten Schritt erkläre ich den LUA-Code zum virtuellen Modul.
Dazu müsst ihr im Modul oben rechts auf „Fortgeschritten“ klicken und ganz nach unten scrollen. Hier seht ihr den LUA-Code der „primären Schleife“. Diese wird permanent wiederholt und der LUA-Code ausgeführt.
Zuerst kommen wir zu den Einstellungen:
Ich bekomme 12.24 Cents pro verkaufter Kilowattstunde vergütet. Das müsst ihr mit euerem individuellen Vergütungssatz eures Netzbetreibers anpassen:
|
1 |
local PayPerKwh = 12.24; |
Als nächstes werden die Grunddaten der Anlage hinterlegt. Ich habe 26 PV-Module auf meinem Hausdach mit jeweils 290 Watt Leistung. Zusammengerechnet (26 x 290) ergibt sich eine Peak-Leistung von 7540 Wp:
|
1 |
local PvSystemWp = 7540; |
Nun wollen wir noch festlegen wie oft über den Modbus aktualisiert werden soll. (60* 5 = 5 min):
|
1 |
local Wait = 60* 5; |
Modbus Register und Parameter
Zunächst einmal geht es in diesem Abschnitt nur um Variablen und Werte die wir vorab definieren und setzten werden.
In den nächsten Zeilen werden die eigene ID, IP-Adresse und Port in Variablen eingelesen. Diese hattet ihr bereits im Abschnitt „Modulkonfiguration“ dieser Beschreibung angegeben. Somit müsst ihr hier nichts ändern!!!!
|
1 2 3 4 |
local thisdevice = fibaro:getSelfId() local InvIPadress = fibaro:getValue(thisdevice, 'IPAddress') local InvPort = fibaro:getValue(thisdevice, 'TCPPort') -- Skript-Code nicht ändern! Die IP und Port habt ihr schon in der Modulkofiguration angegeben (siehe oben)! |
Jede TCP Nachricht über den Modbus enthält einen Header (14 Bytes) mit den folgenden Daten:
- Transaction Identifier (2 Bytes)
- Protocol Identifier (2 Bytes)
- Bytes to follow (2 Bytes)
- Slave ID or Unit Identifier (2 Bytes)
- Function Code (2 Bytes)
- Register Adress (2 Bytes)
- Bytes to Read (2 Bytes)
Dieser Header kann bei anderen Wechselrichtern mit abweichender Modbus-Schnittstelle natürlich anders aufgebaut sein.
Der Modbus-Header wird nun mit Werten befüllt.
1. Der Transaction Identifier (2 Bytes) wird vom Client (Fibaro) gesetzt um eindeutig jede Anfrage zu identifizieren. Der Default Wert = 0.
|
1 |
local TransId = 0; |
2. Der Protocol Identifier (2 Bytes) wird vom Client gesetzt. Der Default Wert = 0.
|
1 |
local ProtId = 0; |
3. Mit Bytes to follow (2 Bytes) legen wir fest wie viele Bytes der Nachricht folgen. Der Default Wert = 6.
|
1 |
local BytesToFlw = 6; |
4. Die SlaveID Address (2 Bytes) ist die Adresse des Wechselrichters. Diese hattet ihr euch wie im Abschnitt 2 „Kommunikation mit dem Wechselrichter“ dieser Beschreibung gemerkt. Bei SMA Wechselrichtern ist dies meistens = 3. Der SunSpec Modbus hingegen = 126!
|
1 |
local UnitIdentifier = 3; |
5. Der Function Code (2 Bytes) wird aus der folgenden Register-Tabelle entnommen. Sie veranschaulicht welche Funktion genutzt werden soll um zu lesen oder zu schreiben!
| CODE | FUNCTION | REFERENCE |
| 01 (01H) | Read Coil (Output) Status | 0xxxx |
| 03 (03H) | Read Holding Registers | 4xxxx |
| 04 (04H) | Read Input Registers | 3xxxx |
| 05 (05H) | Force Single Coil (Output) | 0xxxx |
| 06 (06H) | Preset Single Register | 4xxxx |
| 08 (08H) | Reset Slave | Hidden |
| 15 (0FH) | Force Multiple Coils (Outputs) | 0xxxx |
| 16 (10H) | Preset Multiple Registers | 4xxxx |
| 17 (11H) | Report Slave ID | Hidden |
Da wir nur Daten lesen wollen (Read Input Registers = 3xxxx) ist hier der Default Wert = 3.
|
1 |
local FunctionCode = 3; |
6. Die Register Adress (2 Bytes) ist die Datenadresse des Modbus Registers das uns interessiert. Dazu findet man Details im SMA Manual. Hier werden alle verfügbaren Register und viele weitere Informationen z.B. mögliche Rückgabewerte und deren Bedeutungen aufgelistet!
Beispiel: Beim Aufrufen der Register Adresse 30051 zum Feststellen des Gerätetyps kommt als Antwort 8001 zurück. Dies steht für Inverter bzw. Wechselrichter. Dies haben wir bereits schon einmal getestet mit dem Tool „Modbus Master Sim“ von Radzio, siehe oben!
Weiter Infos unter: http://files.sma.de/dl/2585/WEBBOX-MODBUS-TB-en-19.pdf
Auch hier gilt, andere Wechselrichter haben andere Register. Evtl. müsst ihr dies dann später bei der eigentlichen Interaktion mit dem Wechselrichter bedenken und die Register-Adressen entsprechend anpassen!
|
1 |
local RegisterAdd; |
7. Mit Bytes to Read (2 Bytes) wird angegeben wie viele Register zusammengehörig angefordert werden. Hier ist der Default Wert immer = 2.
|
1 |
local NumRegToRead = 2; |
Somit sind nun alle Werte für den Header definiert!
High und Low Byte
Da die Werte bzw. Registeradressen zum Teil hohe numerische Werte sind und unsere Parameter in der Modbus-Nachricht immer nur 2 Bytes groß sind, müssen wir uns eines Tricks bedienen und die Parameter auftrennen:
- das erste Parameter-Byte -> High Byte, und
- das zweite Parameter-Byte -> Low Byte
Allgemein hat ein Byte = 8 bits und somit 2^8 = 256 verschiedene Zustände.
Zahlen die nun größer als 256 sind werden nun im nächsten höheren (higher) Byte dargestellt.
Die Umrechnungsformel dazu ist:
|
1 |
Parameter = High Byte * (256) + Low Byte |
Dazu nun ein Beispiel:
Beim Aufrufen der Register Adresse 30051 zum Feststellen des Gerätetyps wird die 30051 in High und Low Byte zerlegt:
30051 = 177 * (256) + 99 nach der Formel oben!
Somit wird 30051 dargestellt als 117 High Byte und 99 Low Byte!
Nun legen wir Variablen fest, mit denen wir den Modbus-Header bestimmen können:
- Transaction Identifier (2 Bytes)
|
1 2 3 |
local TransIdHB; --high byte Transaction Identifier local TransIdLB; --low byte Transaction Identifier |
- Protocol Identifier (2 Bytes)
|
1 2 3 |
local ProtIdHB; --high byte Protocol Identifier local ProtIdLB; --low byte Protocol Identifier |
- Bytes to follow (2 Bytes)
|
1 2 3 |
local BytesToFlwHB; --high byte Bytes to follow local BytesToFlwLB; --low byte Bytes to follow |
- Register Adress (2 Bytes)
|
1 2 3 |
local StartAddHB; --high byte Start Address local StartAddLB; --low byte Start Address |
- Bytes to Read (2 Bytes)
|
1 2 3 |
local NumRegToReadHB; --high byte Number of Registers to read local NumRegToReadLB; --low byte Number of Registers to read |
Mögliche erlaubte Optionen: 1, 10, 100, 1000! Default Wert = 1
|
1 |
local Factor = 1; |
Funktionen
Die nächsten beiden Funktionen wandeln eine Zahl wie im letzten Abschnitt beschrieben sowohl in High Byte als auch in Low Byte um.
|
1 2 3 4 5 6 7 8 9 10 11 |
local function highbyte(regnum) local hb = 0; hb = math.floor(regnum/ 256); return hb; end local function lowbyte(regnum) local lb = 0; lb = regnum% 256; return lb; end |
Diese Funktion wandelt einen String in einen lesbaren String um!
|
1 2 3 4 5 6 7 8 |
local function DumpString(str,spacer) return ( string.gsub(str,"(.)", function (c) return string.format("%02X%s",string.byte(c), spacer or ""); end) ) end |
Modbus Interaktion
Nun wird das Modbus-Register mit der folgenden Funktion (readRegister) angesprochen und ein Rückgabewert ausgelesen.
Übergabeparameter sind die Adresse des Registers und ein etwaiger Teiler!
Wieder unser bereits getestetes Beispiel: Input readRegister (30051, 1) gibt modbusAnswerNr 8001 zurück!
|
1 2 3 |
local function readRegister (modbusRegister, divider) local modbusAnswerRaw; local modbusAnswerNr; |
Nun werden alle Daten aus dem Header in High Byte und Low Byte aufgeteilt:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
TransIdHB = tostring(highbyte(TransId)); TransIdLB = tostring(lowbyte(TransId)); ProtIdHB = tostring(highbyte(ProtId)); ProtIdLB = tostring(lowbyte(ProtId)); BytesToFlwHB = tostring(highbyte(BytesToFlw)); BytesToFlwLB = tostring(lowbyte(BytesToFlw)); StartAddHB = tostring(highbyte(modbusRegister)); StartAddLB = tostring(lowbyte(modbusRegister)); NumRegToReadHB = tostring(highbyte(NumRegToRead)); NumRegToReadLB = tostring(lowbyte(NumRegToRead)); UnitIdentifier = tostring(UnitIdentifier); FunctionCode = tostring(FunctionCode); |
Die TCP Verbindung zum Wechselrichter wird aufgebaut mit der vorher definierten IP-Adresse und Port. Wir bedienen uns dazu des Net-Frameworks:
|
1 |
local tcpSocket = Net.FTcpSocket(InvIPadress, InvPort); |
Eine Nachricht wird erstellt entsprechend aller Daten die wir vorher im Header festgelegt haben:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
sendbuffer=string.char( TransIdHB, TransIdLB, ProtIdHB, ProtIdLB, BytesToFlwHB, BytesToFlwLB, UnitIdentifier, FunctionCode, StartAddHB, StartAddLB, NumRegToReadHB, NumRegToReadLB); |
Jetzt brauchen wir noch einen Timeout falls es nicht klappt:
|
1 |
tcpSocket:setReadTimeout(1000); |
Jetzt warten wir um sicher zu gehen, dass die Verbindung auch wirklich steht (1000 = 1 Sekunde).
|
1 |
fibaro:sleep(250); |
Die erstellte Nachricht wird verschickt:
|
1 |
local bytes, errorCode = tcpSocket:write(sendbuffer); |
Jetzt warten wir um sicher zu gehen, dass der Modbus Zeit hat zu antworten (1000 = 1 Sekunde).
|
1 |
fibaro:sleep(250); |
Die Antwort wird gelesen:
|
1 2 |
local result, err = tcpSocket:read(); if err == 0 then |
Der String wird aus der Antwort extrahiert und lesbar gemacht:
|
1 2 3 4 5 6 7 |
modbusAnswerRaw = string.sub((DumpString(result)), 19); modbusAnswerNr = tonumber(modbusAnswerRaw, 16); else --Das war wohl nichts -> Fehler! fibaro:debug("Error!") fibaro:debug(err) end |
Die Verbindung zum Wechselrichter wird wieder getrennt:
|
1 |
tcpSocket:disconnect(); |
Zum Schluss wird noch durch einen evtl. vorher festgelegten Faktor geteilt (zur Berechnung von z.B. Kilowatt & Watt) und dabei aber vermieden, dass einen Division durch Null stattfindet!
|
1 2 3 4 5 |
if modbusAnswerNr > 0 and divider > 0 then modbusAnswerNr = modbusAnswerNr / divider; end return modbusAnswerNr; end |
Hauptprogramm
Da das Hauptprogramm immer wieder mit Zeitverzögerung von vorne startet um eine kontinuierliche Abfrage der Werte zu gewährleisten bauen wir uns eine Endlosschleife:
|
1 |
while true do |
Die Zeit der aktuellen Abfrage wird bestimmt um sie später mit auszugeben:
|
1 |
fibaro:call(fibaro:getSelfId(), "setProperty", "ui.Label1.value", os.date("%a, %H:%M:%S")); |
Als nächstes wollen wir die aktuelle Wechselstrom-Leistung in Watt über alle Phasen abrufen. Dazu nutzen wir das Register 30775. Siehe zu Registern auch im Abschnitt „Modbus Register und Parameter“!
|
1 2 3 |
RegisterAdd = 30775; Factor=1; local PvPowerWatt = readRegister (RegisterAdd,Factor); |
Jetzt wollen wir noch überprüfen, ob der Rückgabe-Wert überhaupt Sinn macht. Bei Nacht und ohne PV-Produktion eliminieren wir hiermit falsche Ausgabe:
|
1 2 3 |
if PvPowerWatt < 1 or PvPowerWatt > PvSystemWp then PvPowerWatt = 0,0001; end |
Der Wert der Variable PvPowerWatt sollte niemals 0 (Null) sein, damit nicht aus versehen eine Division durch Null passiert und das Programm sich aufhängt. Deswegen wird einfach ein sehr kleiner beliebiger Wert, hier 0,0001 gewählt.
Und nun geben wir den Wert aus:
|
1 2 |
fibaro:call(fibaro:getSelfId(), "setProperty", "ui.Label2.value", (PvPowerWatt.." Watt")); fibaro:debug("PV-Leistung: "..PvPowerWatt.." Watt"); |
Ein weiterer interessanter Wert den wir uns anschauen möchten ist die prozentuale Leistung der Photovoltaik-Anlage.
Der minimal Wert wäre bei fehlendem Sonnenschein = 0, und der maximale Wert wäre nun die maximal theoretische Spitzenleistung den die Anlage hergibt.
|
1 2 3 |
local OpGrade = (100 / PvSystemWp * PvPowerWatt); fibaro:call(fibaro:getSelfId(), "setProperty", "ui.Label3.value", (string.format("%." .. (2) .. "f", OpGrade).." %")); fibaro:debug("Auslastung: "..OpGrade.." %"); |
Als weiteren Wert interessiert uns der Tagesertrag in Kilowattstunden. Dafür wollen wir das Register 30535 abfragen. Da das Register Wh zurück gibt müssen wir mit dem Faktor 1000 teilen um kWh zu erhalten.
|
1 2 |
RegisterAdd = 30535; Factor=1000; |
Nun wird der Tagesertrag abgerufen und die Variable „DayYieldWh“ geschrieben.
|
1 2 3 |
local DayYieldWh = readRegister (RegisterAdd,Factor); fibaro:call(fibaro:getSelfId(), "setProperty", "ui.Label4.value", (string.format("%." .. (2) .. "f", DayYieldWh).." kWh")); fibaro:debug("Tagesertrag: "..DayYieldWh.." kWh"); |
Zum Schluss wollen wir noch wissen wie viel Ertrag die PV-Anlage am heutigen Tag erwirtschaftet hat. Dazu nutzen wir die Vergütung pro kWh und multiplizieren Sie mit dem aktuellen Ertrag.
|
1 2 3 |
local Remuneration = ((DayYieldWh * PayPerKwh) / 100); fibaro:call(fibaro:getSelfId(), "setProperty", "ui.Label5.value", (string.format("%." .. (2) .. "f", Remuneration).." €")); fibaro:debug("Vergütung: "..Remuneration.." €"); |
Im letzten Schritt wird das Symbol entsprechend der Leistung in 10er Stufen prozentual angezeigt. Dazu müsst ihr nun die aus dem Abschnitt „Symbole für das virtuelle Modul einrichten“ notierten Nummern der Bilder hier einfügen. Zur Erinnerung, das erste Bild hieß „User1001.png“ und somit muss die Nummer "1001" für das erste Bild genutzt werden. Passt nun den folgenden Code entsprechend eurer Bildernummern an:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
if(OpGrade < 1) then Icon 0% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1001) elseif (OpGrade >= 1 and OpGrade < 14) then Icon 10% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1002) elseif (OpGrade >= 15 and OpGrade < 24) then Icon 20% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1003) elseif (OpGrade >= 25 and OpGrade < 34) then Icon 30% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1004) elseif (OpGrade >= 35 and OpGrade < 44) then Icon 40% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1005) elseif (OpGrade >= 45 and OpGrade < 54) then Icon 50% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1006) elseif (OpGrade >= 55 and OpGrade < 64) then Icon 60% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1007) elseif (OpGrade >= 65 and OpGrade < 74) then Icon 70% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1008) elseif (OpGrade >= 75 and OpGrade < 84) then Icon 80% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1009) elseif (OpGrade >= 85 and OpGrade < 94) then Icon 90% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1010) elseif (OpGrade >= 95) then Icon 100% PV Leistung fibaro:call(thisdevice, "setProperty", "currentIcon", 1011) end |
Die Symbole warden nun entsprechend der PV-Leistung in der App angezeigt.
Da wir das Fibaro System nicht unnötig überlasten wollen soll die ganze Schleif nur zeitverzögert weiter durchlaufen werden:
|
1 2 |
fibaro:sleep(Wait*1000); end |
Viel Spaß wünsche ich beim Basteln und freue mich über Kommentare!
euer Kingfisher
Cool, gibt es auch eine Statistik, wie die Auslastung über die Zeit/Tag/Monat war? Außerdem wäre schön zu sehen, wie viel Strom aktuell abgegeben wird, also der Wert des virtuellen Gerätes berücksichtigt wird (optional).
Hallo Jeggy,
danke erst mal, hat mich auch ein paar Tage arbeit gekostet ;-)
Du willst wahrscheinlich wissen, wie hoch dein Eigenverbrauch contra Einspeisung ist?
Du kannst die Eigenverbrauchsdaten vom SMA Wechselrichter leider nicht auslesen, weil er die gar nicht kennt. Wenn du per Modbus diese Daten haben möchtest, dann benötigst du einen Modbusfähiges Strommessgerät bzw. Energy-Meter, das du vor deinen Hausstromzähler hängst. Um dann die Daten in Fibaro zu nutzen bzw. Statistiken zu erhalten wäre wahrscheinlich das Aeon Labs Z-Wave 3 Zangenamperemeter (AEO_HEM3) interessant. Im Forum wurde bereits darüber diskutiert: https://www.siio.de/board/thema/aeon-labs-z-wave-3-zangenamperemeter-aeo_hem3/
Grüße
KF
Hi Kingfisher,
danke für das Feedback,... sicher eine Idee,... Vielleicht noch ein paar Ideen für eine mögliche Erweiterung. Die Werte sind derzeit immer tagesbezogen. Der Wert vom Vortag ist nicht mehr sichtbar. Interessant wäre die Möglichkeit auf vergangene Tage z.B. Monat/Jahr zuzugreifen und eine mögliche Einbindung in die Fibaro Energiestatistik, sofern das Fibaro zulässt :)
Hi Jeggy,
ja absolut. Allerdings ist das alles bei Fibaro sehr eingeschränkt. Leider interessiert bei Fibaro nur der Verbrauch. Es wäre sicher super, wenn man nicht nur Verbraucher darstellen könnte, sondern auch den Energie-"eingang"! Ich nutze zur Zeit für meine Energiestatistiken die von SMA bereitgestellten Daten aus dem Sunnyportal . Vielleicht wäre ein Ansatz zur Visualisierung der Energiewerte und Statistiken den iobroker zu nutzen. Die Visualisierungsmöglichkeiten sind da echt klasse!
Grüße
KF
ich kriege es nicht zum laufen ;-(
Wo klemmts?
Ein gutes Gerät und eine sensationelle Beschreibung. Es funktioniert auch am Sunny Boy 4000TL-21
Vielen Dank für den Beitrag! Ein Portierung auf Z-Way wäre super!
Habe mich inzwischen schlau gemacht, für Openhab gibt es ja bereits ein Binding was die Auslesung über das SMA Energy Meter anbietet.
Hier ein Beispiel wie man das ganze dann mit der Heizungsanlage koppelt:
https://community.openhab.org/t/optimisation-usage-of-power-excess-of-photovoltaic-system/69672
Hi, zunächst mal danke für das tolle Modul. Das hätte ich mich nicht getraut selbst zu programmieren.
Bei den aktuellen SMA WR scheint der Parameter für die Tagesleistung nicht mehr vorhanden zu sein, es gibt nur eine Gesamtleistung, was natürlich auch nett ist.
Das System scheint sich jetzt stärker auf den Sunny Home Manager abzustützen, der die eingespeiste und selbst verbrauchte Leistung direkt am Zähler misst. Der WR holt die Daten vom Home Manager und stellt alles im Webinterface oder im Sunny Portal dar. Was ich nicht herausgefunden habe, ist ob man diese Informationen auch irgendwie per Modbus oder mit einem Webinterface abfragen kann. Es wäre natürlich extrem praktisch, wenn die Haussteuerung wüsste, wieviel zusätzliche PV Leistung zur Verfügung steht und die diversen z-wave Geräte entsprechend steuert.
Hast Du eine Idee, wie man das realisieren könnte?
Michael
Ich habe heute den VD in Betrieb genommen. Jedoch schmeißt der mir für den tagesertrag und die Vergütung enorm hohe Zahlen raus. Woran kann das liegen ?
Hallo Kingfisher,
tolle Arbeit ! Ist das VD noch verfügbar ? Der Link geht leider nicht mehr.
Gruß Ingolf Börner
ich kann PV_Stromerzeugung.vfib nicht runter laden. kann mir jemand die datei zur verfügung stellen?