FHEMWiki - Benutzerbeiträge [de]

Strombörse

2025-06-24T16:41:39Z

Ch.eick:

[[Bild:Screenshot 2024-01-23 122115.png|mini|400px|rechts|EVU_Tibber_connect]]
Diese Seite beinhaltet Informationen für die Anbindung von Energieversorgungsunternehmen (EVU), die ihre Preise nach der Strombörse z.B. im Stundenrhythmus anbieten.

Als Beispiel wären da:
# {{Link2Forum|Topic=130407|LinkText=Tibber - im Forum}}
# {{Link2Forum|Topic=135906|LinkText=aWATTar - im Forum}}
# {{Link2Forum|Topic=135906|LinkText=EPEX_Spot}}

Diese Wiki Seite ist noch in Bearbeitung!!!

== 1. Tibber mit Tibber Pulse ==
Eine momentan verbreitete Methode zur Anbindung an Tibber ist ein Lesekopf auf dem EVU Zähler, der als "Tibber Pulse" vertrieben wird. Damit wird ein bestehender digitaler EVU Zähler ausgelesen und die Werte per LAN zu Tibber gesendet. Über eine API bei Tibber können dann die Verbrauchswerte und Kosten, sowie ein Live Stream (WebSocket) abgefragt werden.

Die im Folgenden beschriebenen Beispieldevices bieten die oben genannte Abfrage der API mit WebSocket und HTTPMOD. Das EVU_Tibber Device dient der Darstellung und Steuerung.

=== Vorausetzungen ===
* FHEM mit einer installierten MySQL DbLog (FileLog wird nicht unterstützt)
* KeyValue() (wird hier beschrieben)
* homeID und personal Token/Access Token/Connect Token
* Tibber Pulse Lesekopf auf dem digitalen EVU Zähler
* Man sollte bereits Tibber Kunde sein, da ansonsten nur Demo Daten abgrufen werden können

=== Token ===
Der Token wird leider unterschiedlich bezeichnet, aber egal ob er personal Token, Access Token oder Connect Token heisst, es bezieht sich auf den gleichen.

Erhältlich ist dieser aktuell (Oktober 24) unter https://developer.tibber.com/

Dort bitte mit deinen Zugangsdaten einloggen ("Sign In", oben rechts) und man bekommt den Access Token direkt angezeigt.

=== homeID ===
Um eine HomeID zu erhalten, muss zuerst der Pulse mit dem Internet bzw. tibber verbunden werden. Wenn die App glücklich ist, gehts hier weiter:

Man loggt sich wieder ein unter https://developer.tibber.com/. Dort geht man dann zum API Explorer.

Leider ist keine der Demo-Abfragen geeignet, die homeID zu erfahren. Dafür gibt man ins linke fenster folgenden Code ein: <syntaxhighlight lang="Perl">
{
viewer {
homes {
id
address {
address1
postalCode
}
}
}
}
</syntaxhighlight>
Dann startet man mit dem Play-Pfeil und bekommt auf der rechten Seite etwa folgende Ausgabe:

<syntaxhighlight lang="Perl">
{
"data": {
"viewer": {
"homes": [
{
"id": "1234abcd-12ab-34cd-56ef-1234abcd12ab
"address": {
"address1": "Musterstr.1",
"postalCode": "12345"
}
}
]
}
}
}
</syntaxhighlight>
Diese ID ist die homeID und kann unten verwendet werden.

=== EVU_Tibber_connect ===
Das EVU_Tibber_connect fragt mit HTTPMOD Statistiken auf der Tibber API Webseite ab. Zusätzlich wurde in den userReadings die WebSocket Verbindung für die Live Daten integriert.
* Die WebSocket Verbindung wurde leicht angepasst '''[[Websocket|von hier]]''' übernommen
* Im Forum wurde dies '''{{Link2Forum|Topic=130407|Message=1298863|LinkText=ab hier}}''' bearbeitet

==== Verwendete Module ====
* HTTPMOD
* DbLog
* DbRep
* DOIF
* KeyValue()

==== Ablage der homeID und des Tokens ====
Eine Verbindung zur Tibber API mit den '''tatsächlichen Preisen bekommen nur Kunden''', ansonsten kann man eine Demo mit Kosten in Schwedischen Kronen testweise abfragen.

In diesem Beispiel Device kann man seine homeID und sein Token entweder als Attribut ablegen oder man macht einen Eintrag im KeyStore von FHEM, wodurch man nicht so leicht versehentlich seine Daten im Forum postet.

Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils.pm .

===== Beispiel KeyValue() =====
'''Achtung, der KeyValue ist kein Schutz für Passwort oder Keys!'''
Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im FHEM Device oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

====== KeyValue() Funktion in der ~/FHEM/99_myUtils.pm ======
<syntaxhighlight lang="Perl">
sub KeyValue {
my ($step, $index, $value) = @_;
my $key = getUniqueId().$index;
my $e_value = "";
my $error;

if (eval "use Digest::MD5;1") {
$key = Digest::MD5::md5_hex(unpack "H*", $key);
$key .= Digest::MD5::md5_hex($key);
}

if ($step eq "read") {
($error, $value) = getKeyValue($index);

if ( defined($error) ) {
Log3 $index,3, "$index, can't read key from FhemUtils/uniqueID: $error";
return undef;
}

if ( defined($value) ) {
my $dec_value = '';

for my $char (map { pack('C', hex($_)) } ($value =~ /(..)/g)) {
my $decode = chop($key);
$dec_value .= chr(ord($char)^ord($decode));
$key = $decode.$key;
}
return $dec_value;
}
else {
Log3 $index,3,"$index, no key found in FhemUtils/uniqueID";
return undef;
}
}

if ($step eq "store") {
for my $char (split //, $value) {
my $encode = chop($key);
$e_value .= sprintf("%.2x",ord($char)^ord($encode));
$key = $encode.$key;
}
$error = setKeyValue($index, $e_value);
return "error while saving key : $error" if(defined($error));
return "Key successfully saved in FhemUtils/uniqueID Key $index";
}

};
</syntaxhighlight>

====== Ablegen der homeID und des Token ======
In der FHEM Kommandozeile legt man seinen Daten wie folgt im KeyValue ab. Hier wären als Beispiel der Demo Zugang von Tibber.
Das "read" ist dann auch direkt der erste Test, bevor man weiter macht.
<syntaxhighlight lang="Perl">
{KeyValue("store","EVU_Tibber_connect_token","5K4MVS-OjfWhK_4yrjOlFe1F6kJXPVf7eQYggo8ebAE")}
{KeyValue("store","EVU_Tibber_connect_homeID","96a14971-525a-4420-aae9-e5aedaa129ff")}

{KeyValue("read","EVU_Tibber_connect_token")}
{KeyValue("read","EVU_Tibber_connect_homeID")}
</syntaxhighlight>

===== Beispiel Attribut für homeID und Token =====
Oder, sobald das EVU_Tibber_connect Device erstellt wurde, als Attribut.
<syntaxhighlight lang="Perl">
attr EVU_Tibber_connect ws_homeId 96a14971-525a-4420-aae9-e5aedaa129ff
attr EVU_Tibber_connect ws_myId 96a14971-525a-4420-aae9-e5aedaa129ff <<<< Dies kann wohl eine frei gewählte ID sein, was hier der Einfachheithalber gleich der homeId gesetzt wurde.
attr EVU_Tibber_connect ws_token 5K4MVS-OjfWhK_4yrjOlFe1F6kJXPVf7eQYggo8ebAE
</syntaxhighlight>

==== EVU_Tibber_connect RAW Device====
Das Device EVU_Tibber_connect dient der Verbindung zur Tibber API. Zusätzlich wird für die Abfrege der Live Daten innerhalb der userReadings eine WebSocket Verbindung zu Tibber aufgebaut. Tibber stellt jeweils gegen 14:00 Uhr die Daten für den nächsten Tag bereit, wodurch von 00:00 - 14:00 Uhr diese Information im EVU_Tibber_connect noch nicht angezeigt werden kann.
Das Device arbeitet über die userReadings mit einem MySQL DbRep Device, was somit eine MySQL DbLog Verwendung im FHEM voraussetzt. '''Die Verwendung von FileLog ist nicht unterstützt!'''
<syntaxhighlight lang="Perl">
defmod EVU_Tibber_connect HTTPMOD https://api.tibber.com/v1-beta/gql 0
attr EVU_Tibber_connect userattr ws_homeId ws_minInterval ws_myId ws_token ws_websocketURL
attr EVU_Tibber_connect DbLogExclude .*
attr EVU_Tibber_connect DbLogInclude total_cost_.*,fc0_trigger.*
attr EVU_Tibber_connect comment Version 2024.01.22 14:00 \
https://developer.tibber.com/explorer\
\
In der FHEM Kommandozeile könnt Ihr das token und die homeID im KeyStore ablegen.\
Bitte lest dazu das Thema KeyStore im Wiki und legt die Funktion in Eure 99_myUtils.\
\
{KeyValue("store","EVU_Tibber_connect_token","5K4MVS-OjfWhK_4yrjOlFe1F6kJXPVf7eQYggo8ebAE")}\
{KeyValue("store","EVU_Tibber_connect_homeID","96a14971-525a-4420-aae9-e5aedaa129ff")}\
\
Hierduch kann man einen wirtschaftlicheren trigger_price berechnen lassen:\
setreading EVU_Tibber compensation_grid <Eure Einspeisevergütung>\
\
# Berechnung eines Default Schwellwertes als täglicher Niedrigpreis\
(fc_avg - fc_min) /2 + fc_min\
\
# Abschätzung von Wirtschaftlichkeit beim Speicher Laden, falls Tibber zu teuer wird\
# compensation_grid kann auch auf einen für Euch passenden Wert gesetzt werden\
(fc_avg - compensation_grid) *0.85
attr EVU_Tibber_connect disable 0
attr EVU_Tibber_connect enableControlSet 1
attr EVU_Tibber_connect get01-1Name current_currency
attr EVU_Tibber_connect get01-2Name current_level
attr EVU_Tibber_connect get01-3Name current_date
attr EVU_Tibber_connect get01-3OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get01-4Name current_price
attr EVU_Tibber_connect get01-4OExpr $val *100
attr EVU_Tibber_connect get01Data { "query": "{viewer {home(id:\"%%homeID%%\") {currentSubscription {priceInfo {current {total startsAt currency level}}}}}}" }
attr EVU_Tibber_connect get01Header01 Content-Type: application/json
attr EVU_Tibber_connect get01Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get01JSON data_viewer_home_currentSubscription_priceInfo_current
attr EVU_Tibber_connect get01Name 01_priceInfo
attr EVU_Tibber_connect get01URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect get02-10Name fc0_03_total
attr EVU_Tibber_connect get02-11Name fc0_04_startsAt
attr EVU_Tibber_connect get02-11OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-12Name fc0_04_total
attr EVU_Tibber_connect get02-13Name fc0_05_startsAt
attr EVU_Tibber_connect get02-13OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-14Name fc0_05_total
attr EVU_Tibber_connect get02-15Name fc0_06_startsAt
attr EVU_Tibber_connect get02-15OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-16Name fc0_06_total
attr EVU_Tibber_connect get02-17Name fc0_07_startsAt
attr EVU_Tibber_connect get02-17OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-18Name fc0_07_total
attr EVU_Tibber_connect get02-19Name fc0_08_startsAt
attr EVU_Tibber_connect get02-19OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-1Name current_date
attr EVU_Tibber_connect get02-1OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-20Name fc0_08_total
attr EVU_Tibber_connect get02-21Name fc0_09_startsAt
attr EVU_Tibber_connect get02-21OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-22Name fc0_09_total
attr EVU_Tibber_connect get02-23Name fc0_10_startsAt
attr EVU_Tibber_connect get02-23OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-24Name fc0_10_total
attr EVU_Tibber_connect get02-25Name fc0_11_startsAt
attr EVU_Tibber_connect get02-25OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-26Name fc0_11_total
attr EVU_Tibber_connect get02-27Name fc0_12_startsAt
attr EVU_Tibber_connect get02-27OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-28Name fc0_12_total
attr EVU_Tibber_connect get02-29Name fc0_13_startsAt
attr EVU_Tibber_connect get02-29OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-2Name current_price
attr EVU_Tibber_connect get02-2OExpr $val *100
attr EVU_Tibber_connect get02-30Name fc0_13_total
attr EVU_Tibber_connect get02-31Name fc0_14_startsAt
attr EVU_Tibber_connect get02-31OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-32Name fc0_14_total
attr EVU_Tibber_connect get02-33Name fc0_15_startsAt
attr EVU_Tibber_connect get02-33OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-34Name fc0_15_total
attr EVU_Tibber_connect get02-35Name fc0_16_startsAt
attr EVU_Tibber_connect get02-35OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-36Name fc0_16_total
attr EVU_Tibber_connect get02-37Name fc0_17_startsAt
attr EVU_Tibber_connect get02-37OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-38Name fc0_17_total
attr EVU_Tibber_connect get02-39Name fc0_18_startsAt
attr EVU_Tibber_connect get02-39OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-3Name fc0_00_startsAt
attr EVU_Tibber_connect get02-3OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-40Name fc0_18_total
attr EVU_Tibber_connect get02-41Name fc0_19_startsAt
attr EVU_Tibber_connect get02-41OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-42Name fc0_19_total
attr EVU_Tibber_connect get02-43Name fc0_20_startsAt
attr EVU_Tibber_connect get02-43OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-44Name fc0_20_total
attr EVU_Tibber_connect get02-45Name fc0_21_startsAt
attr EVU_Tibber_connect get02-45OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-46Name fc0_21_total
attr EVU_Tibber_connect get02-47Name fc0_22_startsAt
attr EVU_Tibber_connect get02-47OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-48Name fc0_22_total
attr EVU_Tibber_connect get02-49Name fc0_23_startsAt
attr EVU_Tibber_connect get02-49OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-4Name fc0_00_total
attr EVU_Tibber_connect get02-50Name fc0_23_total
attr EVU_Tibber_connect get02-51Name fc1_00_startsAt
attr EVU_Tibber_connect get02-51OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-52Name fc1_00_total
attr EVU_Tibber_connect get02-53Name fc1_01_startsAt
attr EVU_Tibber_connect get02-53OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-54Name fc1_01_total
attr EVU_Tibber_connect get02-55Name fc1_02_startsAt
attr EVU_Tibber_connect get02-55OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-56Name fc1_02_total
attr EVU_Tibber_connect get02-57Name fc1_03_startsAt
attr EVU_Tibber_connect get02-57OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-58Name fc1_03_total
attr EVU_Tibber_connect get02-59Name fc1_04_startsAt
attr EVU_Tibber_connect get02-59OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-5Name fc0_01_startsAt
attr EVU_Tibber_connect get02-5OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-60Name fc1_04_total
attr EVU_Tibber_connect get02-61Name fc1_05_startsAt
attr EVU_Tibber_connect get02-61OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-62Name fc1_05_total
attr EVU_Tibber_connect get02-63Name fc1_06_startsAt
attr EVU_Tibber_connect get02-63OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-64Name fc1_06_total
attr EVU_Tibber_connect get02-65Name fc1_07_startsAt
attr EVU_Tibber_connect get02-65OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-66Name fc1_07_total
attr EVU_Tibber_connect get02-67Name fc1_08_startsAt
attr EVU_Tibber_connect get02-67OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-68Name fc1_08_total
attr EVU_Tibber_connect get02-69Name fc1_09_startsAt
attr EVU_Tibber_connect get02-69OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-6Name fc0_01_total
attr EVU_Tibber_connect get02-70Name fc1_09_total
attr EVU_Tibber_connect get02-71Name fc1_10_startsAt
attr EVU_Tibber_connect get02-71OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-72Name fc1_10_total
attr EVU_Tibber_connect get02-73Name fc1_11_startsAt
attr EVU_Tibber_connect get02-73OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-74Name fc1_11_total
attr EVU_Tibber_connect get02-75Name fc1_12_startsAt
attr EVU_Tibber_connect get02-75OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-76Name fc1_12_total
attr EVU_Tibber_connect get02-77Name fc1_13_startsAt
attr EVU_Tibber_connect get02-77OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-78Name fc1_13_total
attr EVU_Tibber_connect get02-79Name fc1_14_startsAt
attr EVU_Tibber_connect get02-79OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-7Name fc0_02_startsAt
attr EVU_Tibber_connect get02-7OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-80Name fc1_14_total
attr EVU_Tibber_connect get02-81Name fc1_15_startsAt
attr EVU_Tibber_connect get02-81OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-82Name fc1_15_total
attr EVU_Tibber_connect get02-83Name fc1_16_startsAt
attr EVU_Tibber_connect get02-83OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-84Name fc1_16_total
attr EVU_Tibber_connect get02-85Name fc1_17_startsAt
attr EVU_Tibber_connect get02-85OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-86Name fc1_17_total
attr EVU_Tibber_connect get02-87Name fc1_18_startsAt
attr EVU_Tibber_connect get02-87OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-88Name fc1_18_total
attr EVU_Tibber_connect get02-89Name fc1_19_startsAt
attr EVU_Tibber_connect get02-89OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-8Name fc0_02_total
attr EVU_Tibber_connect get02-90Name fc1_19_total
attr EVU_Tibber_connect get02-91Name fc1_20_startsAt
attr EVU_Tibber_connect get02-91OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-92Name fc1_20_total
attr EVU_Tibber_connect get02-93Name fc1_21_startsAt
attr EVU_Tibber_connect get02-93OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-94Name fc1_21_total
attr EVU_Tibber_connect get02-95Name fc1_22_startsAt
attr EVU_Tibber_connect get02-95OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-96Name fc1_22_total
attr EVU_Tibber_connect get02-97Name fc1_23_startsAt
attr EVU_Tibber_connect get02-97OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02-98Name fc1_23_total
attr EVU_Tibber_connect get02-9Name fc0_03_startsAt
attr EVU_Tibber_connect get02-9OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get02Data { "query": "{viewer {home(id:\"%%homeID%%\") {currentSubscription {priceInfo {current {total startsAt} today {total startsAt} tomorrow {total startsAt}}}}}}" }
attr EVU_Tibber_connect get02Header01 Content-Type: application/json
attr EVU_Tibber_connect get02Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get02JSON data_viewer_home_currentSubscription_priceInfo
attr EVU_Tibber_connect get02Name 02_priceAll
attr EVU_Tibber_connect get02URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect get03-1Name nodes_00_00_from
attr EVU_Tibber_connect get03-1OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get03-2Name nodes_00_00_cost
attr EVU_Tibber_connect get03-2OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get03-3Name nodes_00_00_consumption
attr EVU_Tibber_connect get03-4Name nodes_00_01_from
attr EVU_Tibber_connect get03-4OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get03-50Name nodes_00_01_cost
attr EVU_Tibber_connect get03-50OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get03-5Name nodes_00_01_cost
attr EVU_Tibber_connect get03-5OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get03-6Name nodes_00_01_consumption
attr EVU_Tibber_connect get03-7Name nodes_00_02_from
attr EVU_Tibber_connect get03-7OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get03-8Name nodes_00_02_cost
attr EVU_Tibber_connect get03-8OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get03-9Name nodes_00_02_consumption
attr EVU_Tibber_connect get03Data { "query": "{viewer {home(id:\"%%homeID%%\") {consumption(resolution: HOURLY, last: 3) {nodes {from cost consumption }}}}}"}
attr EVU_Tibber_connect get03Header01 Content-Type: application/json
attr EVU_Tibber_connect get03Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get03Name 03_consumption_hour
attr EVU_Tibber_connect get03RegOpt g
attr EVU_Tibber_connect get03Regex \{"from":"([\d+-]+T[\d+:]+\.000[+-][\d+:]+)","cost":(null|\d+\.\d+|0),"consumption":(null|\d+\.\d+|0)\}
attr EVU_Tibber_connect get03URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect get04-10Name nodes_24_03_from
attr EVU_Tibber_connect get04-10OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-11Name nodes_24_03_cost
attr EVU_Tibber_connect get04-11OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-12Name nodes_24_03_consumption
attr EVU_Tibber_connect get04-13Name nodes_24_04_from
attr EVU_Tibber_connect get04-13OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-14Name nodes_24_04_cost
attr EVU_Tibber_connect get04-14OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-15Name nodes_24_04_consumption
attr EVU_Tibber_connect get04-16Name nodes_24_05_from
attr EVU_Tibber_connect get04-16OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-17Name nodes_24_05_cost
attr EVU_Tibber_connect get04-17OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-18Name nodes_24_05_consumption
attr EVU_Tibber_connect get04-19Name nodes_24_06_from
attr EVU_Tibber_connect get04-19OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-1Name nodes_24_00_from
attr EVU_Tibber_connect get04-1OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-20Name nodes_24_06_cost
attr EVU_Tibber_connect get04-20OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-21Name nodes_24_06_consumption
attr EVU_Tibber_connect get04-22Name nodes_24_07_from
attr EVU_Tibber_connect get04-22OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-23Name nodes_24_07_cost
attr EVU_Tibber_connect get04-23OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-24Name nodes_24_07_consumption
attr EVU_Tibber_connect get04-25Name nodes_24_08_from
attr EVU_Tibber_connect get04-25OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-26Name nodes_24_08_cost
attr EVU_Tibber_connect get04-26OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-27Name nodes_24_08_consumption
attr EVU_Tibber_connect get04-28Name nodes_24_09_from
attr EVU_Tibber_connect get04-28OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-29Name nodes_24_09_cost
attr EVU_Tibber_connect get04-29OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-2Name nodes_24_00_cost
attr EVU_Tibber_connect get04-2OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-30Name nodes_24_09_consumption
attr EVU_Tibber_connect get04-31Name nodes_24_10_from
attr EVU_Tibber_connect get04-31OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-32Name nodes_24_10_cost
attr EVU_Tibber_connect get04-32OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-33Name nodes_24_10_consumption
attr EVU_Tibber_connect get04-34Name nodes_24_11_from
attr EVU_Tibber_connect get04-34OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-35Name nodes_24_11_cost
attr EVU_Tibber_connect get04-35OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-36Name nodes_24_11_consumption
attr EVU_Tibber_connect get04-37Name nodes_24_12_from
attr EVU_Tibber_connect get04-37OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-38Name nodes_24_12_cost
attr EVU_Tibber_connect get04-38OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-39Name nodes_24_12_consumption
attr EVU_Tibber_connect get04-3Name nodes_24_00_consumption
attr EVU_Tibber_connect get04-40Name nodes_24_13_from
attr EVU_Tibber_connect get04-40OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-41Name nodes_24_13_cost
attr EVU_Tibber_connect get04-41OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-42Name nodes_24_13_consumption
attr EVU_Tibber_connect get04-43Name nodes_24_14_from
attr EVU_Tibber_connect get04-43OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-44Name nodes_24_14_cost
attr EVU_Tibber_connect get04-44OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-45Name nodes_24_14_consumption
attr EVU_Tibber_connect get04-46Name nodes_24_15_from
attr EVU_Tibber_connect get04-46OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-47Name nodes_24_15_cost
attr EVU_Tibber_connect get04-47OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-48Name nodes_24_15_consumption
attr EVU_Tibber_connect get04-49Name nodes_24_16_from
attr EVU_Tibber_connect get04-49OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-4Name nodes_24_01_from
attr EVU_Tibber_connect get04-4OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-50Name nodes_24_16_cost
attr EVU_Tibber_connect get04-50OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-51Name nodes_24_16_consumption
attr EVU_Tibber_connect get04-52Name nodes_24_17_from
attr EVU_Tibber_connect get04-52OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-53Name nodes_24_17_cost
attr EVU_Tibber_connect get04-53OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-54Name nodes_24_17_consumption
attr EVU_Tibber_connect get04-55Name nodes_24_18_from
attr EVU_Tibber_connect get04-55OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-56Name nodes_24_18_cost
attr EVU_Tibber_connect get04-56OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-57Name nodes_24_18_consumption
attr EVU_Tibber_connect get04-58Name nodes_24_19_from
attr EVU_Tibber_connect get04-58OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-59Name nodes_24_19_cost
attr EVU_Tibber_connect get04-59OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-5Name nodes_24_01_cost
attr EVU_Tibber_connect get04-5OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-60Name nodes_24_19_consumption
attr EVU_Tibber_connect get04-61Name nodes_24_20_from
attr EVU_Tibber_connect get04-61OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-62Name nodes_24_20_cost
attr EVU_Tibber_connect get04-62OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-63Name nodes_24_20_consumption
attr EVU_Tibber_connect get04-64Name nodes_24_21_from
attr EVU_Tibber_connect get04-64OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-65Name nodes_24_21_cost
attr EVU_Tibber_connect get04-65OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-66Name nodes_24_21_consumption
attr EVU_Tibber_connect get04-67Name nodes_24_22_from
attr EVU_Tibber_connect get04-67OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-68Name nodes_24_22_cost
attr EVU_Tibber_connect get04-68OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-69Name nodes_24_22_consumption
attr EVU_Tibber_connect get04-6Name nodes_24_01_consumption
attr EVU_Tibber_connect get04-70Name nodes_24_23_from
attr EVU_Tibber_connect get04-70OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-71Name nodes_24_23_cost
attr EVU_Tibber_connect get04-71OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-72Name nodes_24_23_consumption
attr EVU_Tibber_connect get04-7Name nodes_24_02_from
attr EVU_Tibber_connect get04-7OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get04-8Name nodes_24_02_cost
attr EVU_Tibber_connect get04-8OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get04-9Name nodes_24_02_consumption
attr EVU_Tibber_connect get04Data { "query": "{viewer {home(id:\"%%homeID%%\") {consumption(resolution: HOURLY, last: 24) {nodes {from cost consumption}}}}}"}
attr EVU_Tibber_connect get04Header01 Content-Type: application/json
attr EVU_Tibber_connect get04Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get04Name 04_consumption_hour_24
attr EVU_Tibber_connect get04RegOpt g
attr EVU_Tibber_connect get04Regex \{"from":"([\d+-]+T[\d+:]+\.000[+-][\d+:]+)","cost":(null|\d+\.\d+|0),"consumption":(null|\d+\.\d+|0)\}
attr EVU_Tibber_connect get04URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect get05AutoNumLen 4
attr EVU_Tibber_connect get05Data { "query": "{viewer {home(id:\"%%homeID%%\") {consumption(resolution: HOURLY, last: 100) {nodes {from cost consumption}}}}}"}
attr EVU_Tibber_connect get05Header01 Content-Type: application/json
attr EVU_Tibber_connect get05Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get05JSON data_viewer_home
attr EVU_Tibber_connect get05Name 05_consumption_hourly_100
attr EVU_Tibber_connect get05URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect get06-10Name Adresse_07_Telefon
attr EVU_Tibber_connect get06-11Name Adresse_01_Vorname
attr EVU_Tibber_connect get06-12Name Adresse_02_Nachname
attr EVU_Tibber_connect get06-1Name Adresse_03_Strasse
attr EVU_Tibber_connect get06-2Name Adresse_05_Ort
attr EVU_Tibber_connect get06-3Name Adresse_06_Land
attr EVU_Tibber_connect get06-4Name Adresse_05_Ort
attr EVU_Tibber_connect get06-5Name Adresse_06_Land
attr EVU_Tibber_connect get06-6Name Adresse_09_latitude
attr EVU_Tibber_connect get06-7Name Adresse_10_longitude
attr EVU_Tibber_connect get06-8Name Adresse_04_Plz
attr EVU_Tibber_connect get06-9Name Adresse_08_eMail
attr EVU_Tibber_connect get06Data { "query": "{viewer {home(id:\"%%homeID%%\") {address {address1 address2 address3 postalCode city country latitude longitude} owner {firstName lastName contactInfo {email mobile}}}}}" }
attr EVU_Tibber_connect get06Header01 Content-Type: application/json
attr EVU_Tibber_connect get06Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get06JSON data_viewer_home
attr EVU_Tibber_connect get06Name 06_address
attr EVU_Tibber_connect get06URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect get07-10Name nodes_24_03_from
attr EVU_Tibber_connect get07-10OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-11Name nodes_24_03_cost
attr EVU_Tibber_connect get07-11OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-12Name nodes_24_03_consumption
attr EVU_Tibber_connect get07-13Name nodes_24_04_from
attr EVU_Tibber_connect get07-13OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-14Name nodes_24_04_cost
attr EVU_Tibber_connect get07-14OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-15Name nodes_24_04_consumption
attr EVU_Tibber_connect get07-16Name nodes_24_05_from
attr EVU_Tibber_connect get07-16OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-17Name nodes_24_05_cost
attr EVU_Tibber_connect get07-17OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-18Name nodes_24_05_consumption
attr EVU_Tibber_connect get07-19Name nodes_24_06_from
attr EVU_Tibber_connect get07-19OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-1Name features_realTimeConsumptionEnabled
attr EVU_Tibber_connect get07-1OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-20Name nodes_24_06_cost
attr EVU_Tibber_connect get07-20OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-21Name nodes_24_06_consumption
attr EVU_Tibber_connect get07-22Name nodes_24_07_from
attr EVU_Tibber_connect get07-22OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-23Name nodes_24_07_cost
attr EVU_Tibber_connect get07-23OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-24Name nodes_24_07_consumption
attr EVU_Tibber_connect get07-25Name nodes_24_08_from
attr EVU_Tibber_connect get07-25OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-26Name nodes_24_08_cost
attr EVU_Tibber_connect get07-26OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-27Name nodes_24_08_consumption
attr EVU_Tibber_connect get07-28Name nodes_24_09_from
attr EVU_Tibber_connect get07-28OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-29Name nodes_24_09_cost
attr EVU_Tibber_connect get07-29OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-2Name features_id
attr EVU_Tibber_connect get07-2OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-30Name nodes_24_09_consumption
attr EVU_Tibber_connect get07-31Name nodes_24_10_from
attr EVU_Tibber_connect get07-31OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-32Name nodes_24_10_cost
attr EVU_Tibber_connect get07-32OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-33Name nodes_24_10_consumption
attr EVU_Tibber_connect get07-34Name nodes_24_11_from
attr EVU_Tibber_connect get07-34OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-35Name nodes_24_11_cost
attr EVU_Tibber_connect get07-35OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-36Name nodes_24_11_consumption
attr EVU_Tibber_connect get07-37Name nodes_24_12_from
attr EVU_Tibber_connect get07-37OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-38Name nodes_24_12_cost
attr EVU_Tibber_connect get07-38OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-39Name nodes_24_12_consumption
attr EVU_Tibber_connect get07-3Name nodes_24_00_consumption
attr EVU_Tibber_connect get07-40Name nodes_24_13_from
attr EVU_Tibber_connect get07-40OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-41Name nodes_24_13_cost
attr EVU_Tibber_connect get07-41OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-42Name nodes_24_13_consumption
attr EVU_Tibber_connect get07-43Name nodes_24_14_from
attr EVU_Tibber_connect get07-43OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-44Name nodes_24_14_cost
attr EVU_Tibber_connect get07-44OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-45Name nodes_24_14_consumption
attr EVU_Tibber_connect get07-46Name nodes_24_15_from
attr EVU_Tibber_connect get07-46OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-47Name nodes_24_15_cost
attr EVU_Tibber_connect get07-47OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-48Name nodes_24_15_consumption
attr EVU_Tibber_connect get07-49Name nodes_24_16_from
attr EVU_Tibber_connect get07-49OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-4Name nodes_24_01_from
attr EVU_Tibber_connect get07-4OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-50Name nodes_24_16_cost
attr EVU_Tibber_connect get07-50OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-51Name nodes_24_16_consumption
attr EVU_Tibber_connect get07-52Name nodes_24_17_from
attr EVU_Tibber_connect get07-52OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-53Name nodes_24_17_cost
attr EVU_Tibber_connect get07-53OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-54Name nodes_24_17_consumption
attr EVU_Tibber_connect get07-55Name nodes_24_18_from
attr EVU_Tibber_connect get07-55OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-56Name nodes_24_18_cost
attr EVU_Tibber_connect get07-56OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-57Name nodes_24_18_consumption
attr EVU_Tibber_connect get07-58Name nodes_24_19_from
attr EVU_Tibber_connect get07-58OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-59Name nodes_24_19_cost
attr EVU_Tibber_connect get07-59OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-5Name nodes_24_01_cost
attr EVU_Tibber_connect get07-5OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-60Name nodes_24_19_consumption
attr EVU_Tibber_connect get07-61Name nodes_24_20_from
attr EVU_Tibber_connect get07-61OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-62Name nodes_24_20_cost
attr EVU_Tibber_connect get07-62OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-63Name nodes_24_20_consumption
attr EVU_Tibber_connect get07-64Name nodes_24_21_from
attr EVU_Tibber_connect get07-64OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-65Name nodes_24_21_cost
attr EVU_Tibber_connect get07-65OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-66Name nodes_24_21_consumption
attr EVU_Tibber_connect get07-67Name nodes_24_22_from
attr EVU_Tibber_connect get07-67OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-68Name nodes_24_22_cost
attr EVU_Tibber_connect get07-68OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-69Name nodes_24_22_consumption
attr EVU_Tibber_connect get07-6Name nodes_24_01_consumption
attr EVU_Tibber_connect get07-70Name nodes_24_23_from
attr EVU_Tibber_connect get07-70OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-71Name nodes_24_23_cost
attr EVU_Tibber_connect get07-71OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-72Name nodes_24_23_consumption
attr EVU_Tibber_connect get07-7Name nodes_24_02_from
attr EVU_Tibber_connect get07-7OExpr $val =~ s/T/ /g ;; substr($val,0,19)
attr EVU_Tibber_connect get07-8Name nodes_24_02_cost
attr EVU_Tibber_connect get07-8OExpr ($val ne "0" and $val ne "null")? round($val,4) : $val
attr EVU_Tibber_connect get07-9Name nodes_24_02_consumption
attr EVU_Tibber_connect get07Data { "query": "{viewer {home(id:\"%%homeID%%\") {id features{realTimeConsumptionEnabled} } } }" }
attr EVU_Tibber_connect get07Header01 Content-Type: application/json
attr EVU_Tibber_connect get07Header02 Authorization: Bearer %%token%%
attr EVU_Tibber_connect get07JSON data_viewer_home
attr EVU_Tibber_connect get07Name 07_realTimeConsumptionEnabled
attr EVU_Tibber_connect get07RegOpt g
attr EVU_Tibber_connect get07Regex \{"from":"([\d+-]+T[\d+:]+\.000[+-][\d+:]+)","cost":(null|\d+\.\d+|0),"consumption":(null|\d+\.\d+|0)\}
attr EVU_Tibber_connect get07URL https://api.tibber.com/v1-beta/gql
attr EVU_Tibber_connect group PV Steuerung EVU
attr EVU_Tibber_connect icon stromzaehler_icon
attr EVU_Tibber_connect replacement01Mode expression
attr EVU_Tibber_connect replacement01Regex %%token%%
attr EVU_Tibber_connect replacement01Value {KeyValue("read","EVU_Tibber_connect_token")}
attr EVU_Tibber_connect replacement02Mode expression
attr EVU_Tibber_connect replacement02Regex %%homeID%%
attr EVU_Tibber_connect replacement02Value {KeyValue("read","EVU_Tibber_connect_homeID")}
attr EVU_Tibber_connect requestData { "query": "{viewer {home(id:\"%%homeID%%\") {currentSubscription {priceInfo {current {total energy tax startsAt }}}}}}" }
attr EVU_Tibber_connect requestHeader1 Content-Type: application/json
attr EVU_Tibber_connect requestHeader2 Authorization: Bearer %%token%%
attr EVU_Tibber_connect room Strom->Boerse
attr EVU_Tibber_connect showBody 1
attr EVU_Tibber_connect showError 1
attr EVU_Tibber_connect sortby 313
attr EVU_Tibber_connect timeout 30
attr EVU_Tibber_connect userReadings ws_connect:ws_cmd:.connect {\
my $hash = $defs{$name};;\
my $devState = DevIo_IsOpen($hash);;\
return "Device already open" if (defined($devState));;\
\
# establish connection to websocket\
# format must also include portnumber if a path is to be specified\
$hash->{DeviceName} = AttrVal($name, "ws_websocketURL", "wss:echo.websocket.org:443");;\
\
# special headers needed for Tibber, see also Developer Tools in Browser\
$hash->{header}{'Sec-WebSocket-Protocol'} = 'graphql-transport-ws';;\
$hash->{header}{'Host'} = 'websocket-api.tibber.com';;\
$hash->{header}{'Origin'} = 'https://developer.tibber.com';;\
\
# callback function when "select()" signals data for us\
# websocket Ping/Pongs are treated in DevIo but still call this function\
$hash->{directReadFn} = sub () {\
my $hash = $defs{$name};;\
\
# we can read without closing the DevIo, because select() signalled data\
my $buf = DevIo_SimpleRead($hash);;\
\
# if read fails, close device\
if(!defined($buf)) {\
DevIo_CloseDev($hash);;\
$buf = "not_connected";;\
}\
\
#Log(3, "$name:$reading: websocket data: >>>$buf<<<");;\
\
# only update our reading if buffer is not empty and if last update is older than minInterval\
if ($buf ne "") {\
my $websocketDataAge = ReadingsAge($name, "ws_websocketData", 3600);;\
my $minInterval = AttrVal($name, "ws_minInterval", 0);;\
my $isNext = ($buf =~ /.*id.*type.*next.*payload.*data.*liveMeasurement.*/s);;\
\
readingsBeginUpdate($hash);;\
readingsBulkUpdate($hash, "ws_websocketData", "$buf") if ($isNext && $websocketDataAge > $minInterval);;\
readingsBulkUpdate($hash, "ws_websocketData", "$buf") if (!$isNext);;\
readingsEndUpdate($hash, 1);;\
#Log(3, "$name:$reading: websocket data written to reading");;\
}\
};;\
\
# open DevIo websocket\
DevIo_OpenDev($hash, 0, undef, sub(){\
my ($hash, $error) = @_;;\
return "$error" if ($error);;\
\
my $token = AttrVal($name, "ws_token", "???");;\
$token = KeyValue("read","EVU_Tibber_connect_token") if ($token eq "???");;\
\
DevIo_SimpleWrite($hash, '{"type":"connection_init","payload":{"token":"'.$token.'"}}', 2);;\
});;\
readingsBulkUpdate($hash, "ws_websocketData", "");;\
#Log(3, "$name:$reading: websocket data cleared in reading");;\
\
return POSIX::strftime("%H:%M:%S",localtime(time()));;\
},\
\
ws_disconnect:ws_cmd:.disconnect {\
Log(3, "$name: disconnect");;\
my $hash = $defs{$name};;\
RemoveInternalTimer($hash);;\
DevIo_SimpleRead($hash);;\
DevIo_CloseDev($hash);;\
\
return POSIX::strftime("%H:%M:%S",localtime(time()));;\
},\
\
ws_onDisconnect {\
my $myState = ReadingsVal($name, "state", "???");;\
my $myData = ReadingsVal($name, "ws_websocketData", "???");;\
return if ($myState ne "disconnected" and $myData ne "not_connected");;\
\
## timer callback function, called after a few seconds to initiate a reconnect\
my $timerFunction = sub() {\
my ($arg) = @_;;\
my $hash = $defs{$name};;\
my $devState = DevIo_IsOpen($hash);;\
\
# only re-connect if device is not connected\
readingsSingleUpdate($hash, "ws_cmd", "connect", 1) if (!defined($devState));;\
};;\
RemoveInternalTimer($name.$reading.'Timer');;\
\
# wait a random time before reconnect (exponential backoff TBD):\
my $rwait = int(rand(200)) + 30;;\
InternalTimer(gettimeofday() + $rwait, $timerFunction, $name.$reading.'Timer');;\
\
#set cmd to a new value, informs user and allows to retrigger when timer expires\
my $hash = $defs{$name};;\
readingsBulkUpdate($hash, "ws_cmd", "reconnect attempt in $rwait seconds");;\
\
return POSIX::strftime("%H:%M:%S",localtime(time()));;\
},\
\
ws_onTimeout:ws_websocketData:.* {\
#re-establish websocket connection if no data received in the past ten minutes\
#but only if our reading "ws_cmd" was not set to the value "disconnect"\
\
#Log(3, "$name:$reading: websocket data triggert ws_onTimeout");;\
\
#timeout in seconds when the connection is considered dead\
my $timeoutTime = 600;;\
\
# function to execute when timeout expired\
# defining the function here in the userReading, allows us to insert variables directly\
my $timerFunction = sub() {\
my ($arg) = @_;;\
my $hash = $defs{$name};;\
my $rCmd = ReadingsVal($name, "ws_cmd", "???");;\
my $age = ReadingsAge($name, "ws_websocketData", 0);;\
\
Log(3, "$name: onTimeoutTimer triggered >>$arg<<");;\
\
#do not do anything further if disconnect is on purpose\
if ( $rCmd eq "disconnect" ) {\
Log(3, "$name: ws_cmd was set to disconnect");;\
return;;\
}\
\
# for whatever reason, we triggered to soon (80%)\
if ( $age < $timeoutTime*0.8 ) {\
Log(3, "$name: ws_websocketData is not outdated");;\
return;;\
}\
\
DevIo_CloseDev($hash);;\
Log(3, "$name: onTimeoutTimer closed DevIo...");;\
\
readingsSingleUpdate($hash, "ws_cmd", "connect", 1);;\
Log(3, "$name: onTimeoutTimer set ws_cmd to value 'connect'");;\
};;\
\
#Log(3, "$name:$reading: onTimeout function defined");;\
\
#remove/cancel previous timers, because we got fresh data and countdown starts again\
RemoveInternalTimer($name.$reading.'Timer');;\
\
#set timer to expire and execute function defined above, give special arg as identifier\
InternalTimer(gettimeofday() + $timeoutTime, $timerFunction, $name.$reading.'Timer');;\
\
return POSIX::strftime("%H:%M:%S",localtime(time()));;\
},\
\
ws_onConnectionAck:ws_websocketData:.*connection_ack.* {\
#ws_websocketData contains the string "connection_ack"\
Log(3, "$name:$reading: got connection ack");;\
\
# do not proceed if connection is lost\
my $hash = $defs{$name};;\
my $devState = DevIo_IsOpen($hash);;\
return "Device not open" if (!defined($devState));;\
\
readingsBulkUpdate($hash, "ws_cmd", "got connection ack");;\
\
my $homeId = AttrVal($name, "ws_homeId", "???");;\
$homeId = KeyValue("read","EVU_Tibber_connect_homeID") if ($homeId eq "???");;\
\
my $myId = AttrVal($name, "ws_myId", "???");;\
$myId = KeyValue("read","EVU_Tibber_connect_homeID") if ($myId eq "???");;\
\
# build the query, do it in pieces, the comma at the end caused perl errors\
# so we put it together in this not very elegant way\
my $json = '{ "id":"'. $myId .'", "type":"subscribe"'.", ";;\
$json .= '"payload":{';;\
$json .= '"variables":{}'.", ";;\
$json .= '"extensions":{}'.", ";;\
$json .= '"query":"subscription { liveMeasurement( homeId: \"'.$homeId.'\" ) ';;\
#$json .= '{ timestamp power accumulatedConsumption accumulatedCost currency minPower averagePower maxPower signalStrength }}"';;\
$json .= '{ timestamp power lastMeterConsumption accumulatedConsumption accumulatedProduction ';;\
$json .= 'accumulatedProductionLastHour accumulatedCost accumulatedReward currency minPower averagePower maxPower ';;\
$json .= 'powerProduction powerReactive powerProductionReactive minPowerProduction maxPowerProduction lastMeterProduction ';;\
$json .= 'powerFactor voltagePhase1 voltagePhase2 voltagePhase3 signalStrength }}"';;\
$json .= '}}';;\
\
#send the string via websocket as ASCII\
Log(3, "$name:$reading: sending JSON: >>>$json<<<");;\
DevIo_SimpleWrite($hash, $json, 2);;\
\
return POSIX::strftime("%H:%M:%S",localtime(time()));;\
},\
\
ws_onNextLiveMeasurement:ws_websocketData:.*next.*payload.*data.*liveMeasurement.* {\
#websocketData contains next-live-measurement-data\
my $val = ReadingsVal($name, "ws_websocketData", "{}");;\
my %res = %{json2nameValue($val, undef, undef, "payload_data_liveMeasurement.*")};;\
\
my $ret = "got values for:\n";;\
foreach my $k (sort keys %res) {\
$ret .= "$k\n";;\
readingsBulkUpdate($hash, makeReadingName($k), $res{$k});;\
}\
return $ret;;\
},\
\
nodes_TIMESTAMP:nodes_00_00_cost.* {\
my ($timestamp,$value) = 2x0;;\
my $tmp = 0;;\
\
for (my $loop_last = 0;; $loop_last <= 2;; $loop_last++) {\
$timestamp = ReadingsVal("$NAME","nodes_00_".sprintf("%02d",$loop_last)."_from","null");;\
$value = ReadingsVal("$NAME","nodes_00_".sprintf("%02d",$loop_last)."_cost","null");;\
\
if ( $value ne "null" ) {\
# Eintragen der Kosten für die Stunde\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','nodes_cost','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
# Eintragen des Verbrauchs für die Stunde\
$value = ReadingsVal("$NAME","nodes_00_".sprintf("%02d",$loop_last)."_consumption","null");;\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','nodes_consumption','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
} else {\
$tmp = "null";;\
}\
} # end for\
if ($tmp eq "null") {\
$timestamp = $tmp\
}\
$timestamp;;\
},\
\
nodes_TIMESTAMP:nodes_24_00_cost.* {\
my ($timestamp,$value) = 2x0;;\
my $tmp = 0;;\
\
for (my $loop_last = 0;; $loop_last <= 23;; $loop_last++) {\
$timestamp = ReadingsVal("$NAME","nodes_24_".sprintf("%02d",$loop_last)."_from","null");;\
$value = ReadingsVal("$NAME","nodes_24_".sprintf("%02d",$loop_last)."_cost","null");;\
\
if ( $value ne "null" ) {\
# Eintragen der Kosten für die Stunde\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','nodes_cost','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
# Eintragen des Verbrauchs für die Stunde\
$value = ReadingsVal("$NAME","nodes_24_".sprintf("%02d",$loop_last)."_consumption","null");;\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','nodes_consumption','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
} else {\
$tmp = "null";;\
}\
} # end for\
if ($tmp eq "null") {\
$timestamp = $tmp\
}\
$timestamp;;\
},\
\
nodes_TIMESTAMP:05_consumption_hourly_100-0001.* {\
my ($timestamp,$value) = 2x0;;\
\
for (my $loop_last = 1;; $loop_last <= 300;; $loop_last += 3) {\
\
$timestamp = ReadingsVal("$NAME","05_consumption_hourly_100-".sprintf("%04d",$loop_last+2),"null");; # timestamp\
$timestamp =~ s/T/ /g ;;\
$timestamp = substr($timestamp,0,19);;\
$value = ReadingsVal("$NAME","05_consumption_hourly_100-".sprintf("%04d",$loop_last+1),"null");; # cost\
\
if ( $value ne "" ) {\
$value = round($value,4);;\
# print $timestamp." ".$value."\n";;\
\
# Eintragen der Kosten für die Stunde\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','nodes_cost','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
# Eintragen des Verbrauchs für die Stunde\
$value = ReadingsVal("$NAME","05_consumption_hourly_100-".sprintf("%04d",$loop_last),"null");; # consumption\
$value = round($value,4);;\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','nodes_consumption','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
}\
} # end for\
\
$timestamp;;\
},\
\
nodes_cost_avg:nodes_TIMESTAMP.* {\
## Berechnung des Tages Wertes\
if ( ReadingsVal("$NAME","nodes_TIMESTAMP","null") ne "null" ) {\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT cast(avg(VALUE)*100 AS DECIMAL(4,2)) FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_cost'\
AND TIMESTAMP >= curdate() ;;") ;;\
} else {\
ReadingsVal("$NAME","nodes_cost_avg","null")\
}\
},\
\
nodes_cost_min:nodes_TIMESTAMP.* {\
## Ermittlung des minimal Wertes\
if ( ReadingsVal("$NAME","nodes_TIMESTAMP","null") ne "null" ) {\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT cast(min(VALUE)*100 AS DECIMAL(4,2)) FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_cost'\
AND TIMESTAMP >= curdate() ;;") ;;\
} else {\
ReadingsVal("$NAME","nodes_cost_min","null")\
}\
},\
\
nodes_cost_max:nodes_TIMESTAMP.* {\
## Ermittlung des maximal Wertes\
if ( ReadingsVal("$NAME","nodes_TIMESTAMP","null") ne "null" ) {\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT cast(max(VALUE)*100 AS DECIMAL(4,2)) FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_cost'\
AND TIMESTAMP >= curdate() ;;") ;;\
} else {\
ReadingsVal("$NAME","nodes_cost_max","null")\
}\
},\
\
nodes_consumption_day:nodes_TIMESTAMP.* {\
## Berechnung des Tages Verbrauches\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT cast(sum(VALUE) AS DECIMAL(10,4)) FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_consumption'\
AND date(TIMESTAMP) = curdate() ;;") ;;\
},\
\
nodes_consumption_month:nodes_TIMESTAMP.* {\
## Berechnung des Monats Verbrauches\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT cast(sum(VALUE) AS DECIMAL(10,4)) FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_consumption'\
AND YEAR(TIMESTAMP) = YEAR(curdate())\
AND MONTH(TIMESTAMP) = MONTH(curdate()) ;;") ;;\
},\
\
nodes_consumption_year:nodes_TIMESTAMP.* {\
## Berechnung des Jahres Verbrauches\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT cast(sum(VALUE) AS DECIMAL(10,4)) FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_consumption'\
AND YEAR(TIMESTAMP) = YEAR(curdate()) ;;") ;;\
},\
\
fc_avg:current_price.* {\
## Berechnung des durchschnitt Wertes\
my $fc_avg = 0;;\
my $fc = 0;;\
\
if (ReadingsVal("$NAME","fc1_00_startsAt","null") ne "null") { ## Der nächste Tag ist bereits da\
if (AttrVal("$NAME","verbose",0) >=3) {\
Log 3, "$NAME cmd_1 : Tibber Daten für fc1 sind bereits da";;\
}\
$fc = 1;;\
} # end if\
\
for (my $j=0;;$j<=$fc;;$j++){\
for (my $k=0;;$k<=23;;$k++) { ## Summe berechnen\
$fc_avg += ReadingsVal("$NAME",sprintf("fc%d_%02d_total",$j,$k),0);;\
} # end $k\
} # end $j\
\
return round($fc_avg / (24 *(1+$fc)) *100 ,2);; ## Durchschnitt berechnen\
},\
\
fc_med:current_price.* {\
## Berechnung des median Wertes\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT\
cast( ( (SUBSTRING_INDEX(SUBSTRING_INDEX(group_concat(VALUE order by VALUE), ',', floor(1+((count(VALUE)-1) / 2))) , ',', -1))\
+ (SUBSTRING_INDEX(SUBSTRING_INDEX(group_concat(VALUE order by VALUE), ',', ceiling(1+((count(VALUE)-1) / 2))), ',', -1))\
)/2 *100\
AS DECIMAL(4,2))\
FROM history\
WHERE DEVICE='".$NAME."'\
AND ( READING='fc0_total' AND TIMESTAMP >= DATE_FORMAT(NOW(), '%Y-%m-%d 00:00:00')\
OR READING='fc1_total' AND TIMESTAMP >= DATE_FORMAT(NOW() + INTERVAL 1 DAY, '%Y-%m-%d 00:00:00') ) ;;") ;;\
},\
\
fc_min:current_price.* {\
## Ermittlung des minimal Wertes\
my $fc_min = 0;;\
my $fc_tmp = 0;;\
my $fc = 0;;\
\
if (ReadingsVal("$NAME","fc1_00_startsAt","null") ne "null") { ## Der nächste Tag ist bereits da\
$fc = 1;;\
} # end if\
\
for (my $j=0;;$j<=$fc;;$j++){\
for (my $k=0;;$k<=23;;$k++) {\
$fc_tmp = ReadingsVal("$NAME",sprintf("fc%d_%02d_total",$j,$k),0);;\
\
if (($fc_tmp < $fc_min) or ($j == 0 and $k == 0)) {\
$fc_min = $fc_tmp;;\
}\
} # end $k\
} # end $j\
\
return round($fc_min *100 ,2);; ## Von Euro auf Cent umrechnen\
},\
\
fc_max:current_price.* {\
## Ermittlung des minimal Wertes\
my $fc_max = 0;;\
my $fc_tmp = 0;;\
my $fc = 0;;\
\
if (ReadingsVal("$NAME","fc1_00_startsAt","null") ne "null") { ## Der nächste Tag ist bereits da\
$fc = 1;;\
} # end if\
\
for (my $j=0;;$j<=$fc;;$j++){\
for (my $k=0;;$k<=23;;$k++) {\
$fc_tmp = ReadingsVal("$NAME",sprintf("fc%d_%02d_total",$j,$k),0);;\
\
if (($fc_tmp > $fc_max) or ($j == 0 and $k == 0)) {\
$fc_max = $fc_tmp;;\
}\
} # end $k\
} # end $j\
\
return round($fc_max *100 ,2);; ## Von Euro auf Cent umrechnen\
},\
\
fc_trigger_price:fc_avg.* {\
## fc_trigger_price:[fc_avg|compensation_grid].* {\
my $fc_avg = ReadingsVal("$NAME","fc_avg",0);;\
my $fc_min = ReadingsVal("$NAME","fc_min",0);;\
\
# Berechnung eines Default Schwellwertes als täglicher Niedrigpreis\
my $price_level = round( ($fc_avg - $fc_min)/2 + $fc_min , 1);;\
\
# Abschätzung von Wirtschaftlichkeit beim Speicher Laden, falls Tibber zu teuer wird\
if ( ReadingsVal("$NAME","compensation_grid",0) != 0 ) {\
my $price_level_battery = round( ($fc_avg - ReadingsVal("$NAME","compensation_grid",0)) *0.85 , 1) ;;\
if ( $price_level > $price_level_battery ) {\
$price_level = $price_level_battery;;\
}\
}\
$price_level;;\
},\
\
fc0_trigger_start:fc_trigger_price.* {\
my $fc_trigger_price = ReadingsVal("$NAME","fc_trigger_price",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);; $year += 1900;; $mon += 1 ;;\
my $fc_total = 0;;\
\
for (my $loop_hour = $hour;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc0_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total < $fc_trigger_price ) {\
return(sprintf("%02d:00",$loop_hour)) ;;\
}\
} # end for loop_hour\
\
return("null");;\
},\
\
fc0_trigger_stop:fc0_trigger_start.* {\
my $fc = 0;;\
my $loop_hour = 0;;\
my $fc_trigger_price = ReadingsVal("$NAME","fc_trigger_price",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my $fc_trigger_start = ReadingsVal("$NAME","fc0_trigger_start","null");;\
my $fc_trigger_stop = $fc_trigger_start;;\
\
if ( $fc_trigger_start ne "null" ) {\
$fc_trigger_start =~ /(\d\d):/;; $fc_trigger_start = $1 ;;\
my $fc_total = 0;;\
\
for ($loop_hour = $fc_trigger_start;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc".$fc."_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total < $fc_trigger_price ) {\
$fc_trigger_stop = sprintf("%02d:00",$loop_hour) ;;\
} else {\
return(sprintf("%02d:00",$loop_hour));;\
}\
\
# wechsel zum nächsten Tag\
if ( $loop_hour == 23 and $fc == 0 ) {\
$fc = 1;;\
$loop_hour = -1;;\
}\
\
} # end for loop_hour\
}\
\
return($fc_trigger_stop);;\
},\
\
fc0_trigger:fc0_trigger_stop.* {\
\
# Setzen des Triggers für die aktuelle Stunde\
if ( ReadingsVal("$NAME","current_price",100) < ReadingsVal("$NAME","fc_trigger_price",0) ) {\
return("on")\
} else {\
return("off")\
}\
},\
\
fc1_trigger_start:fc_trigger_price.* {\
if (ReadingsVal("$NAME","fc1_00_startsAt","null") ne "null") {\
my $fc_trigger_price = ReadingsVal("$NAME","fc_trigger_price",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);; $year += 1900;; $mon += 1 ;;\
my $fc_total = 0;;\
\
for (my $loop_hour = 0;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc1_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total < $fc_trigger_price ) {\
return(sprintf("%02d:00",$loop_hour)) ;;\
}\
} # end for loop_hour\
}\
return("null");;\
},\
\
fc1_trigger_stop:fc0_trigger_start.* {\
my $loop_hour = 0;;\
my $fc_trigger_price = ReadingsVal("$NAME","fc_trigger_price",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my $fc_trigger_start = ReadingsVal("$NAME","fc1_trigger_start","null");;\
my $fc_trigger_stop = $fc_trigger_start;;\
\
if ( $fc_trigger_start ne "null" ) {\
$fc_trigger_start =~ /(\d\d):/;; $fc_trigger_start = $1 ;;\
my $fc_total = 0;;\
\
for ($loop_hour = $fc_trigger_start;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc1_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total < $fc_trigger_price ) {\
$fc_trigger_stop = sprintf("%02d:00",$loop_hour) ;;\
} else {\
return(sprintf("%02d:00",$loop_hour));;\
}\
\
} # end for loop_hour\
}\
\
return($fc_trigger_stop);;\
},\
\
fc_trigger_max:fc_avg.* {\
my $fc_avg = ReadingsVal("$NAME","fc_avg",0);;\
my $fc_max = ReadingsVal("$NAME","fc_max",0);;\
\
# Berechnung eines Schwellwertes als täglichen Maximalpreises\
my $price_level = round( ($fc_max - $fc_avg)/2 + $fc_avg , 0);;\
\
$price_level;;\
},\
\
fc0_trigger_max_start:fc_trigger_max.* {\
my $fc_trigger_max = ReadingsVal("$NAME","fc_trigger_max",0) /100;;\
\
# Ermitteln des nächsten Trigger_max Fensters\
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);; $year += 1900;; $mon += 1 ;;\
my $fc_total = 0;;\
\
for (my $loop_hour = $hour;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc0_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total > $fc_trigger_max ) {\
return(sprintf("%02d:00",$loop_hour)) ;;\
}\
} # end for loop_hour\
\
return("null");;\
},\
\
fc0_trigger_max_stop:fc0_trigger_max_start.* {\
my $fc = 0;;\
my $loop_hour = 0;;\
my $fc_trigger_max = ReadingsVal("$NAME","fc_trigger_max",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my $fc_trigger_max_start = ReadingsVal("$NAME","fc0_trigger_max_start","null");;\
my $fc_trigger_max_stop = $fc_trigger_max_start;;\
\
if ( $fc_trigger_max_start ne "null" ) {\
$fc_trigger_max_start =~ /(\d\d):/;; $fc_trigger_max_start = $1 ;;\
my $fc_total = 0;;\
\
for ($loop_hour = $fc_trigger_max_start;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc".$fc."_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total > $fc_trigger_max ) {\
$fc_trigger_max_stop = sprintf("%02d:00",$loop_hour) ;;\
} else {\
return(sprintf("%02d:00",$loop_hour));;\
}\
\
# wechsel zum nächsten Tag\
if ( $loop_hour == 23 and $fc == 0 ) {\
$fc = 1;;\
$loop_hour = -1;;\
}\
\
} # end for loop_hour\
}\
\
return($fc_trigger_max_stop);;\
},\
\
fc0_trigger_max:fc0_trigger_max_stop.* {\
\
# Setzen des maximum Triggers für die aktuelle Stunde\
if ( ReadingsVal("$NAME","current_price",0) > ReadingsVal("$NAME","fc_trigger_max",0) ) {\
return("on")\
} else {\
return("off")\
}\
},\
\
fc1_trigger_max_start:fc_trigger_max.* {\
if (ReadingsVal("$NAME","fc1_00_startsAt","null") ne "null") {\
my $fc_trigger_max = ReadingsVal("$NAME","fc_trigger_max",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);; $year += 1900;; $mon += 1 ;;\
my $fc_total = 0;;\
\
for (my $loop_hour = 0;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc1_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total > $fc_trigger_max ) {\
return(sprintf("%02d:00",$loop_hour)) ;;\
}\
} # end for loop_hour\
}\
return("null");;\
},\
\
fc1_trigger_max_stop:fc0_trigger_max_start.* {\
my $loop_hour = 0;;\
my $fc_trigger_max = ReadingsVal("$NAME","fc_trigger_max",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my $fc_trigger_max_start = ReadingsVal("$NAME","fc1_trigger_max_start","null");;\
my $fc_trigger_max_stop = $fc_trigger_max_start;;\
\
if ( $fc_trigger_max_start ne "null" ) {\
$fc_trigger_max_start =~ /(\d\d):/;; $fc_trigger_max_start = $1 ;;\
my $fc_total = 0;;\
\
for ($loop_hour = $fc_trigger_max_start;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc1_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total > $fc_trigger_max ) {\
$fc_trigger_max_stop = sprintf("%02d:00",$loop_hour) ;;\
} else {\
return(sprintf("%02d:00",$loop_hour));;\
}\
\
} # end for loop_hour\
}\
\
return($fc_trigger_max_stop);;\
},\
\
total_cost_day:nodes_TIMESTAMP.* {\
## Berechnung des Tages Wertes\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT CAST(SUM(VALUE) AS DECIMAL(8,2)) AS VALUE\
FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_cost'\
AND date(TIMESTAMP) = curdate() ;;") ;;\
},\
\
total_cost_month:nodes_TIMESTAMP.* {\
## Berechnung des monats Wertes\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT CAST(SUM(VALUE) AS DECIMAL(8,2)) AS VALUE\
FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_cost'\
AND YEAR(TIMESTAMP) = YEAR(curdate())\
AND MONTH(TIMESTAMP) = MONTH(curdate()) ;;") ;;\
},\
\
total_cost_year:nodes_TIMESTAMP.* {\
## Berechnung des Jahres Wertes\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
SELECT CAST(SUM(VALUE) AS DECIMAL(8,2)) AS VALUE\
FROM history\
WHERE DEVICE='".$NAME."'\
AND READING='nodes_cost'\
AND YEAR(TIMESTAMP) = YEAR(curdate()) ;;") ;;\
},\
\
fc_DbLog:fc0_00_total.* {\
my ($timestamp,$date,$hour,$value,$loop_fc_next) = 5x0;;\
\
for (my $loop_fc = 0;; $loop_fc <= 1;; $loop_fc++) {\
$loop_fc_next = $loop_fc +1;;\
$date = ReadingsVal("$NAME","fc".$loop_fc."_00_startsAt","null");;\
if ($date ne "null") {\
$date =~ /([\d+-]+)/;; $date = $1 ;;\
for (my $loop_hour = 0;; $loop_hour <= 23;; $loop_hour++) {\
$hour = sprintf("%02d",$loop_hour);;\
$timestamp = $date." ".$hour.":00:00";;\
$value = ReadingsVal("$NAME","fc".$loop_fc."_".$hour."_total","null");;\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','fc".$loop_fc."_total','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
}\
if (ReadingsVal("$NAME","fc".$loop_fc."_00_startsAt","null") eq ReadingsVal("$NAME","fc".$loop_fc_next."_00_startsAt","null")) {\
fhem("deletereading $NAME fc".$loop_fc_next."_.*");;\
}\
} else {\
fhem("deletereading $NAME fc1_.*");;\
}\
}\
ReadingsTimestamp("$NAME","fc0_00_startsAt","null");;\
}
attr EVU_Tibber_connect verbose 0
attr EVU_Tibber_connect ws_minInterval 54
attr EVU_Tibber_connect ws_websocketURL wss:websocket-api.tibber.com:443/v1-beta/gql/subscriptions
</syntaxhighlight>

==== EVU_Tibber RAW Device ====
Das Device dient der Anzeige und Steuerung des EVU_Tibber_connect Devices.
<syntaxhighlight lang="Perl">
defmod EVU_Tibber DOIF ## Startup Befehle für den WebSocket vom EVU_Tibber_connect\
init\
{ \
Log(0, "$SELF 0 init : ▶️ EVU_Tibber init");;\
fhem("setreading EVU_Tibber_connect ws_cmd connect");; \
if (AttrVal("$SELF","verbose",0) >=3) {\
Log 3, "$SELF 0 WebSocket : ▶️ EVU_Tibber_connect start Websocket";;\
}\
Log(0, "$SELF 0 init : 🏁 EVU_Tibber init done");;\
}\
\
################################################################################################################\
## EVU_Tibber_connect start/stop WebSocket\
EVU_Tibber_connect_ws\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
# or [$SELF:ui_command_2] ## Hier wird das uiTable select ausgewertet\
and [$SELF:ui_command_2] ne "---"\
) {\
\
fhem("setreading EVU_Tibber_connect ws_cmd ".[?$SELF:ui_command_2]);; \
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## 1 Scheduling für das Abholen von Tibber Daten\
1_EVU_Tibber_PriceInfo\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [:03] ## Kurz nach jeder vollen Stunde\
)\
or [$SELF:ui_command_1] eq "1_EVU_Tibber_PriceInfo" ## Hier wird das uiTable select ausgewertet\
) {\
\
::CommandGet(undef, "EVU_Tibber_connect 01_priceInfo");; ## Preis für die aktuelle Stunde\
::CommandGet(undef, "EVU_Tibber_connect 03_consumption_hour");; ## Kosten der letzen drei Stunden\
if (AttrVal("$SELF","verbose",0) >=3) {\
Log 3, "$SELF 1 PriceInfo : Abfrage von Tibber";;\
}\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## 2 Scheduling für das Abholen der Tibber Preise\
2_EVU_Tibber_PriceAll\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
([00:03] or [14:03] ## Ab 14:00 Uhr gibt es die Preise für den nächsten Tag\
)\
or [$SELF:ui_command_1] eq "2_EVU_Tibber_PriceAll" ## Hier wird das uiTable select ausgewertet\
) {\
\
::CommandGet(undef, "EVU_Tibber_connect 02_priceAll");;\
if (AttrVal("$SELF","verbose",0) >=3) {\
Log 3, "$SELF 2 priceAll : Abfrage von Tibber für den nächsten Tag";;\
}\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## 2 Erstellen des Diagramms im uiTable\
3_EVU_Tibber_Diagramm\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [00:05] or [14:05] ## Kurz nach Mitternacht\
)\
or [$SELF:ui_command_1] eq "3_EVU_Tibber_Diagramm" ## Hier wird das uiTable select ausgewertet\
) {\
\
my (@out) = ("") x 2;;\
my $timestamp;;\
\
for (my $j=0;;$j<=1;;$j++){\
\
if (ReadingsVal("EVU_Tibber_connect",sprintf("fc%d_00_startsAt",$j),"null") eq "null") { ## Der nächste Tag ist noch nicht da\
if (AttrVal("$SELF","verbose",0) >=3) {\
Log 3, "$SELF 3 Diagramm : Tibber Daten für fc".$j." sind noch nicht da";;\
}\
\
$timestamp = POSIX::strftime("%Y-%m-%d",localtime(time+86400));; ## Setze das Datum auf morgen\
for (my $k=0;;$k<=24;;$k++) {\
$out[$j] .= sprintf("%s_%02d:00:00 0.0\n", $timestamp, $k);; ## Die Daten mit 0 ergänzen\
}\
$j = 2;; ## Aus der Schleife springen\
\
} else {\
\
for (my $i=0;;$i<=23;;$i++){\
$timestamp = ReadingsVal("EVU_Tibber_connect",sprintf("fc%d_%02d_startsAt",$j,$i),"");;\
$timestamp =~ s/ /_/g;;\
$out[$j] .=$timestamp." ".::round(ReadingsVal("EVU_Tibber_connect",sprintf("fc%d_%02d_total",$j, $i),0)*100,1)."\n";;\
} # End $i\
\
} # End if\
} # End $j\
\
if (AttrVal("$SELF","verbose",0) >=3) {\
Log 3, "$SELF 3 Diagramm : Werte für das Diagramm";;\
print($out[0]);;\
print($out[1]);;\
}\
## Die readings current_price und current_level dienen hier nur als Trigger Events, und müssen für\
## jedes Diagramm unterschiedlich sein, die Daten werden über $out[] bereit gestellt !!\
::DOIF_modify_card_data("EVU_Tibber","EVU_Tibber_connect","current_price","bar1day",0,$out[0]);;\
::DOIF_modify_card_data("EVU_Tibber","EVU_Tibber_connect","current_level","bar1day",-86400,$out[1]);;\
## Mit der Abfrage 03_consumption_hour werden die Trigger erneut ausgelöst\
::CommandGet(undef, "EVU_Tibber_connect 01_priceInfo");; ## Kosten der letzen drei Stunden\
## fhem("get EVU_Tibber_connect 01_priceInfo");; ## Kosten der letzen drei Stunden\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\

attr EVU_Tibber DbLogExclude .*
attr EVU_Tibber comment Version 2023.12.06 13:00 \
Dieses Device benötigt EVU_Tibber_connect als Verbindung zu Tibber.
attr EVU_Tibber disable 0
attr EVU_Tibber group PV Steuerung EVU
attr EVU_Tibber icon stromzaehler_icon
attr EVU_Tibber room Strom->Boerse
attr EVU_Tibber sortby 315
attr EVU_Tibber uiState {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..6}{0} = "style='border-top-style:solid;;border-bottom-style:solid;;border-left-style:solid;;border-left-width:2px;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..6}{1..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..6}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
}\
\
"Kommando<dd>Auswahl</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,1_EVU_Tibber_PriceInfo,2_EVU_Tibber_PriceAll,3_EVU_Tibber_Diagramm") |"LiveMessurement ".widget([$SELF:ui_command_2],"uzsuDropDown,---,connect,disconnect")|""|[EVU_Tibber_connect:ws_cmd]\
\
"Strompreis ".card([EVU_Tibber_connect:current_price:bar1day],undef,undef,0,60,90,0,"fc0 ".::ReadingsVal(Device(),"current_currency",""),undef,"1","130,,,,,,220").card([EVU_Tibber_connect:current_level:bar1day],undef,undef,0,60,90,0,"fc1 ".::ReadingsVal(Device(),"current_currency",""),undef,"1","130,,,,,,220")|\
"nächste 3h ".Price(1)." ".Price(2)." ".Price(3)|"Statistik fc0 ".::ReadingsVal(Device(),"fc_min",0)." min ".::ReadingsVal(Device(),"fc_avg",0)." avg ".::ReadingsVal(Device(),"fc_med",0)." med ".::ReadingsVal(Device(),"fc_max",0)." max"|\
"Trigger fc0 Basis ".widget([EVU_Tibber_connect:compensation_grid],"selectnumbers,0,0.1,12,1,lin")." ".Format("trigger_0")|\
"Trigger fc1 ".Format("trigger_1")
attr EVU_Tibber uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..18}{0} = "style='border-top-style:solid;;border-bottom-style:solid;;border-left-style:solid;;border-left-width:2px;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..18}{1..5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..18}{6} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
sub Device {\
return "$SELF"."_connect";;\
}\
\
sub Cost {\
my($i)=@_;;\
my $currency = (::ReadingsVal(Device(),"current_currency","") eq "EUR")? " €" : "";;\
\
return ::ReadingsVal(Device(),"total_cost_".$i,0).$currency;;\
}\
\
sub Price {\
my($i)=@_;;\
my $j;;\
my $value;;\
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);; $year += 1900;; $mon += 1 ;;\
\
if ($i == 0) {\
$value = ::ReadingsVal(Device(),"current_price",0);;\
$value = ( ::ReadingsVal(Device(),"fc0_trigger","off") eq "on" ) ?\
"".$value."" :\
"".$value."" ;;\
$value .= " ct/kWh";;\
} else {\
$j = $i+$hour;;\
if ($j < 24) {\
$value = ::round(::ReadingsVal(Device(),"fc0_".sprintf("%02d",$j)."_total",0)*100,1);;\
} else {\
$j = $j - 24;;\
$value = ::round(::ReadingsVal(Device(),"fc1_".sprintf("%02d",$j)."_total",0)*100,1);;\
}\
$value = ( ::ReadingsVal(Device(),"fc_trigger_price","0") > $value ) ?\
"".$value."" :\
"".$value."" ;;\
$value = sprintf("%02d",$j)." : ".$value ;;\
}\
return $value;;\
}\
\
sub Format {\
my($i)=@_;;\
\
my $MonthBefore = "LogDBRep_Statistic_previous_Month";;\
my $MonthPrevious = ::ReadingsTimestamp("$MonthBefore","EVU_Tibber_Pulse_nodes_consumption_month","null");;\
$MonthPrevious = ($MonthPrevious ne "null") ? POSIX::strftime("%Y",localtime(::time_str2num(::ReadingsTimestamp("$MonthBefore","EVU_Tibber_Pulse_nodes_consumption_month","null")))) : "null";;\
\
my $YearBefore = "LogDBRep_Statistic_previous_Year";;\
my $YearPrevious = ::ReadingsTimestamp("$YearBefore",Device()."_nodes_consumption_year","null");;\
$YearPrevious = ($YearPrevious ne "null") ? POSIX::strftime("%Y",localtime(::time_str2num(::ReadingsTimestamp("$YearBefore",Device()."_nodes_consumption_year","null")))) : "null";;\
\
if ($i eq "day") {\
return sprintf("%04d",::ReadingsVal(Device(),"nodes_consumption_day",0));;\
} elsif ($i eq "month") {\
my $evu_em = sprintf("%04d",::ReadingsVal(Device(),"nodes_consumption_month",0));;\
$evu_em .= ($MonthPrevious ne "null") ? sprintf(" / %04d", ::ReadingsVal("$MonthBefore","EVU_Tibber_Pulse_nodes_consumption_month",0) ) : "";;\
return $evu_em;;\
} elsif ($i eq "year") {\
my $evu_ey = sprintf("%04d",::ReadingsVal(Device(),"nodes_consumption_year",0));;\
$evu_ey .= ($YearPrevious ne "null") ? sprintf(" / %04d", ::ReadingsVal("$YearBefore","EVU_Tibber_Pulse_nodes_consumption_month",0) ) : "";;\
return $evu_ey;;\
} elsif ($i eq "trigger_0") {\
return ((::ReadingsVal(Device(),"fc0_trigger_start","") eq "null" ) ?\
"Heute kein Trigger mehr unter ".\
::ReadingsVal(Device(),"fc_trigger_price","null")." ct" :\
"Trigger von ".\
::ReadingsVal(Device(),"fc0_trigger_start","00:00")." bis ".::ReadingsVal(Device(),"fc0_trigger_stop","00:00")." unter ".\
::ReadingsVal(Device(),"fc_trigger_price","null")." ct" );;\
} elsif ($i eq "trigger_1") {\
if (::ReadingsVal(Device(),"fc1_00_startsAt","null") ne "null") {\
return ((::ReadingsVal(Device(),"fc1_trigger_start","null") eq "null" ) ?\
"Morgen kein Trigger mehr unter ".\
::ReadingsVal(Device(),"fc_trigger_price","null")." ct" :\
"Morgen ein Trigger von ".\
::ReadingsVal(Device(),"fc1_trigger_start","00:00")." bis ".::ReadingsVal(Device(),"fc1_trigger_stop","00:00")." unter ".\
::ReadingsVal(Device(),"fc_trigger_price","null")." ct" );;\
} else {\
return "Morgen noch kein Trigger vorhanden";;\
}\
}\
return "null";;\
}\
\
}\
\
"Statistiken ".::ReadingsVal(Device(),"current_date",0)." in kWh"|"aktuell"|"heute"|"Monat"|"Jahr"\
\
"Strom<dd>Preis / Kosten</dd>"|Price(0)|Cost("day")|Cost("month")|Cost("year")\
\
## Wenn man das liveMessurment von Tibber verwendet\
"Bezug vom Netz"|\
sprintf("%04d W",([EVU_Tibber_connect:payload_data_liveMeasurement_power] >= 0 ? ::ReadingsVal("EVU_Tibber_connect","payload_data_liveMeasurement_power",0) : 0))|\
Format("day")|Format("month")|Format("year")\
\
"Einspeisung ins Netz"|\
sprintf("%04d W",([EVU_Tibber_connect:payload_data_liveMeasurement_powerProduction] >= 0 ? ::ReadingsVal("EVU_Tibber_connect","payload_data_liveMeasurement_powerProduction",0) : 0))|\
""|""|""\
\
## Wenn man einen eigenes SmartMeter verwendet\
## "Bezug vom Netz"|sprintf("%04d W",([WR_0_KSEM:M_AC_Power] >= 0 ? ::round(::ReadingsVal("WR_0_KSEM","M_AC_Power",0),0) : 0) )|Format("day")|Format("month")|Format("year")\
## "Einspeisung ins Netz"|sprintf("%04d W",([WR_0_KSEM:M_AC_Power] <= 0 ? abs(::round(::ReadingsVal("WR_0_KSEM","M_AC_Power",0),0)) : 0) )|""|""|""
attr EVU_Tibber verbose 3

setstate EVU_Tibber 2024-01-23 10:03:00 ui_command_1 ---
setstate EVU_Tibber 2024-01-20 17:40:53 ui_command_2 ---
</syntaxhighlight>

==== LogDBRep_EVU_Tibber_connect_SQL RAW Device ====
Dieses DbRep Device dient der Verbindung zur MySQL DbLog. Die SQL SELECT Statements wertden im EVU_Tibber_connect Device generiert und über dieses Device in der MySQL DbLog ausgeführt. Der Name des Devices wird ebenfalls generiert und liegt somit fest.
<syntaxhighlight lang="Perl">
defmod LogDBRep_EVU_Tibber_connect_SQL DbRep LogDB
attr LogDBRep_EVU_Tibber_connect_SQL DbLogExclude .*
attr LogDBRep_EVU_Tibber_connect_SQL room System
attr LogDBRep_EVU_Tibber_connect_SQL sqlCmdHistoryLength 5
attr LogDBRep_EVU_Tibber_connect_SQL timeout 20
</syntaxhighlight>

== 2. aWATTar ==

=== Vorausetzungen ===
* FHEM mit einer installierten MySQL DbLog (FileLog wird nicht untertsützt)
* Für die Berechnung der tatsächlichen Kosten benötigt man seine lokalen fix Kosten, die je nach Region unterschiedlich sind.
* Die bisherige Berechnung mit Stand 20240123 wäre wie folgt: round(($val+$val*0.03+1.785)*1.19,2)

=== EVU_aWATTar_connect ===
Das EVU_aWATTar_connect fragt mit HTTPMOD die aWATTar API Webseite ab. Es werden keine Live Verbrauchdaten geliefert.

==== Verwendete Module ====
* HTTPMOD
* DbLog
* DbRep

==== EVU_aWATTar_connect RAW Device ====
Momentan fragt das EVU_aWattar_connect lediglich die aktuellen Preise des Tages ab. Die readings sind an die des EVU_Tibber_connect angelehnt, um im weiteren Verlauf evetuell ein gemeinsames Device für die Anzeige und Steuerung zu erarbeiten.
<syntaxhighlight lang="Perl">
defmod EVU_aWATTar_connect HTTPMOD https://api.awattar.de/v1/marketdata/current.yaml 0
attr EVU_aWATTar_connect DbLogExclude .*
attr EVU_aWATTar_connect comment Version 2024.01.23 13:00\
\
Achtung, momentan werden nur die Börsenpreise ohne die fix Kosten dargestellt.\
\
https://api.awattar.de/v1/marketdata
attr EVU_aWATTar_connect enableControlSet 1
attr EVU_aWATTar_connect get01-15Name fc_max
attr EVU_aWATTar_connect get01-15OExpr round(($val+$val*0.03+1.785)*1.19,2)
attr EVU_aWATTar_connect get01-1Name current_date
attr EVU_aWATTar_connect get01-22Name fc_med
attr EVU_aWATTar_connect get01-22OExpr round(($val+$val*0.03+1.785)*1.19,2)
attr EVU_aWATTar_connect get01-29Name fc_avg
attr EVU_aWATTar_connect get01-29OExpr round(($val+$val*0.03+1.785)*1.19,2)
attr EVU_aWATTar_connect get01-36Name current_price
attr EVU_aWATTar_connect get01-36OExpr round(($val+$val*0.03+1.785)*1.19,2)
attr EVU_aWATTar_connect get01-8Name fc_min
attr EVU_aWATTar_connect get01-8OExpr round(($val+$val*0.03+1.785)*1.19,2)
attr EVU_aWATTar_connect get01Name 01_priceInfo
attr EVU_aWATTar_connect get01RegOpt g
attr EVU_aWATTar_connect get01Regex date_now: (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})|price_low: ([0-9]+[0-9\.]+)|price_high: ([0-9]+[0-9\.]+)|price_median: ([0-9]+[0-9\.]+)|price_average: ([0-9]+[0-9\.]+)|price_current: ([0-9]+[0-9\.]+)
attr EVU_aWATTar_connect get01URL https://api.awattar.de/v1/marketdata/current.yaml
attr EVU_aWATTar_connect get02-10Name fc0_09_total
attr EVU_aWATTar_connect get02-10OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-11Name fc0_10_total
attr EVU_aWATTar_connect get02-11OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-12Name fc0_11_total
attr EVU_aWATTar_connect get02-12OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-13Name fc0_12_total
attr EVU_aWATTar_connect get02-13OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-14Name fc0_13_total
attr EVU_aWATTar_connect get02-14OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-15Name fc0_14_total
attr EVU_aWATTar_connect get02-15OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-16Name fc0_15_total
attr EVU_aWATTar_connect get02-16OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-17Name fc0_16_total
attr EVU_aWATTar_connect get02-17OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-18Name fc0_17_total
attr EVU_aWATTar_connect get02-18OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-19Name fc0_18_total
attr EVU_aWATTar_connect get02-19OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-1Name fc0_00_total
attr EVU_aWATTar_connect get02-1OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-20Name fc0_19_total
attr EVU_aWATTar_connect get02-20OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-21Name fc0_20_total
attr EVU_aWATTar_connect get02-21OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-22Name fc0_21_total
attr EVU_aWATTar_connect get02-22OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-23Name fc0_22_total
attr EVU_aWATTar_connect get02-23OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-24Name fc0_23_total
attr EVU_aWATTar_connect get02-24OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-2Name fc0_01_total
attr EVU_aWATTar_connect get02-2OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-3Name fc0_02_total
attr EVU_aWATTar_connect get02-3OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-4Name fc0_03_total
attr EVU_aWATTar_connect get02-4OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-5Name fc0_04_total
attr EVU_aWATTar_connect get02-5OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-6Name fc0_05_total
attr EVU_aWATTar_connect get02-6OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-7Name fc0_06_total
attr EVU_aWATTar_connect get02-7OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-8Name fc0_07_total
attr EVU_aWATTar_connect get02-8OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02-9Name fc0_08_total
attr EVU_aWATTar_connect get02-9OExpr round(($val+$val*0.03+1.785)*1.19/100,4)
attr EVU_aWATTar_connect get02FollowGet 01_priceInfo
attr EVU_aWATTar_connect get02Name 02_priceDay
attr EVU_aWATTar_connect get02RegOpt g
attr EVU_aWATTar_connect get02Regex (?<=abs_[0-9]{2}_amount: )([0-9]+[0-9\.]+)
attr EVU_aWATTar_connect get02URL https://api.awattar.de/v1/marketdata/current.yaml
attr EVU_aWATTar_connect get03-1Name fc3_00_startsAt
attr EVU_aWATTar_connect get03-1OExpr POSIX::strftime("%Y-%m-%d %H:%M:%S",localtime(substr($val,0,10)))
attr EVU_aWATTar_connect get03-4Name fc3_00_total
attr EVU_aWATTar_connect get03-4OExpr round($val/1000,4)
attr EVU_aWATTar_connect get03Name 02_priceAll
attr EVU_aWATTar_connect get03RegOpt g
attr EVU_aWATTar_connect get03Regex "start_timestamp": (\d{10})|"marketprice": (\d*\.\d*)
attr EVU_aWATTar_connect get03URL https://api.awattar.de/v1/marketdata?start=1701990000000&end=1702159200000
attr EVU_aWATTar_connect group PV Steuerung EVU
attr EVU_aWATTar_connect icon sani_pump
attr EVU_aWATTar_connect room Strom->Boerse
attr EVU_aWATTar_connect sortby 213
attr EVU_aWATTar_connect userReadings fc_trigger_price:fc_avg.* {\
## fc_trigger_price:[fc_avg|compensation_grid].* {\\
my $fc_avg = ReadingsVal("$NAME","fc_avg",0);;\
my $fc_min = ReadingsVal("$NAME","fc_min",0);;\
\
# Berechnung eines Default Schwellwertes als täglicher Niedrigpreis\
my $price_level = round( ($fc_avg - $fc_min)/2 + $fc_min , 1);;\
\
# Abschätzung von Wirtschaftlichkeit beim Speicher Laden, falls Tibber zu teuer wird\
if ( ReadingsVal("$NAME","compensation_grid",0) != 0 ) {\
my $price_level_battery = round( ($fc_avg - ReadingsVal("$NAME","compensation_grid",0)) *0.85 , 1) ;;\
if ( $price_level > $price_level_battery ) {\
$price_level = $price_level_battery;;\
}\
}\
$price_level;;\
},\
\
fc0_trigger_start:fc_trigger_price.* {\
my $fc_trigger_price = ReadingsVal("$NAME","fc_trigger_price",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);; $year += 1900;; $mon += 1 ;;\
my $fc_total = 0;;\
\
for (my $loop_hour = $hour;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc0_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total < $fc_trigger_price ) {\
return(sprintf("%02d:00",$loop_hour)) ;;\
}\
} # end for loop_hour\
\
return("null");;\
},\
\
fc0_trigger_stop:fc0_trigger_start.* {\
my $fc = 0;;\
my $loop_hour = 0;;\
my $fc_trigger_price = ReadingsVal("$NAME","fc_trigger_price",0) /100;;\
\
# Ermitteln des nächsten Trigger Fensters\
my $fc_trigger_start = ReadingsVal("$NAME","fc0_trigger_start","null");;\
my $fc_trigger_stop = $fc_trigger_start;;\
\
if ( $fc_trigger_start ne "null" ) {\
$fc_trigger_start =~ /(\d\d):/;; $fc_trigger_start = $1 ;;\
my $fc_total = 0;;\
\
for ($loop_hour = $fc_trigger_start;; $loop_hour <= 23;; $loop_hour++) {\
$fc_total = ReadingsVal("$NAME","fc".$fc."_".sprintf("%02d",$loop_hour)."_total",0);;\
if ( $fc_total < $fc_trigger_price ) {\
$fc_trigger_stop = sprintf("%02d:00",$loop_hour) ;;\
} else {\
return(sprintf("%02d:00",$loop_hour));;\
}\
\
# wechsel zum nächsten Tag\
if ( $loop_hour == 23 and $fc == 0 ) {\
$fc = 1;;\
$loop_hour = -1;;\
}\
\
} # end for loop_hour\
}\
\
return($fc_trigger_stop);;\
},\
\
fc0_trigger:fc0_trigger_stop.* {\
\
# Setzen des Triggers für die aktuelle Stunde\
if ( ReadingsVal("$NAME","current_price",100) < ReadingsVal("$NAME","fc_trigger_price",0) ) {\
return("on")\
} else {\
return("off")\
}\
},\
\
fc_DbLog:fc0_00_total.* {\
my ($timestamp,$date,$hour,$value,$loop_fc_next) = 5x0;;\
\
for (my $loop_fc = 0;; $loop_fc <= 1;; $loop_fc++) {\
$loop_fc_next = $loop_fc +1;;\
$date = ReadingsVal("$NAME","current_date","null");;\
if ($date ne "null") {\
$date =~ /([\d+-]+)/;; $date = $1 ;;\
for (my $loop_hour = 0;; $loop_hour <= 23;; $loop_hour++) {\
$hour = sprintf("%02d",$loop_hour);;\
$timestamp = $date." ".$hour.":00:00";;\
$value = ReadingsVal("$NAME","fc".$loop_fc."_".$hour."_total","null");;\
::CommandGet(undef, "LogDBRep_".$NAME."_SQL sqlCmdBlocking\
INSERT INTO history (TIMESTAMP,DEVICE,TYPE,READING,VALUE)\
VALUES('".$timestamp."','$NAME','Tibber','fc".$loop_fc."_total','".$value."')\
ON DUPLICATE KEY UPDATE\
VALUE='".$value."';;") ;;\
}\
} else {\
fhem("deletereading $NAME fc1_.*");;\
}\
}\
ReadingsVal("$NAME","current_date","null");;\
}
attr EVU_aWATTar_connect verbose 0
</syntaxhighlight>

==== LogDBRep_EVU_aWATTar_connect_SQL RAW Device ====
Dieses DbRep Device dient der Verbindung zur MySQL DbLog. Die SQL SELECT Statements wertden im EVU_Tibber_connect Device generiert und über dieses Device in der MySQL DbLog ausgeführt. Der Name des Devices wird ebenfalls generiert und liegt somit fest.
<syntaxhighlight lang="Perl">
defmod LogDBRep_EVU_aWATTar_connect_SQL DbRep LogDB
attr LogDBRep_EVU_aWATTar_connect_SQL DbLogExclude .*
attr LogDBRep_EVU_aWATTar_connect_SQL room System
attr LogDBRep_EVU_aWATTar_connect_SQL sqlCmdHistoryLength 5
attr LogDBRep_EVU_aWATTar_connect_SQL timeout 20
</syntaxhighlight>

== 3. EPEX_Spot ==
Das Device ist noch experimentell.
=== Vorausetzungen ===
httpmod

==== EPEX_Spot RAW Device ====
Mit zwei set kann man
<syntaxhighlight lang="Perl">
defmod EPEX_Spot HTTPMOD none
attr EPEX_Spot comment https://api.energy-charts.info\
https://api.energy-charts.info/price?bzn=DE-LU&start=2025-06-25&end=2025-06-25\
\
https://api.energy-charts.info/price?bzn=DE-LU 3600
attr EPEX_Spot disable 0
attr EPEX_Spot extractAllJSON 0
attr EPEX_Spot get01-0Name fc0_00_total
attr EPEX_Spot get01-0OExpr round($val,2)
attr EPEX_Spot get01-10Name fc0_09
attr EPEX_Spot get01-10OExpr round($val,2)
attr EPEX_Spot get01-11Name fc0_10
attr EPEX_Spot get01-11OExpr round($val,2)
attr EPEX_Spot get01-12Name fc0_11
attr EPEX_Spot get01-12OExpr round($val,2)
attr EPEX_Spot get01-13Name fc0_12
attr EPEX_Spot get01-13OExpr round($val,2)
attr EPEX_Spot get01-14Name fc0_13
attr EPEX_Spot get01-14OExpr round($val,2)
attr EPEX_Spot get01-15Name fc0_14
attr EPEX_Spot get01-15OExpr round($val,2)
attr EPEX_Spot get01-16Name fc0_15
attr EPEX_Spot get01-16OExpr round($val,2)
attr EPEX_Spot get01-17Name fc0_16
attr EPEX_Spot get01-17OExpr round($val,2)
attr EPEX_Spot get01-18Name fc0_17
attr EPEX_Spot get01-18OExpr round($val,2)
attr EPEX_Spot get01-19Name fc0_18
attr EPEX_Spot get01-19OExpr round($val,2)
attr EPEX_Spot get01-1Name fc0_00
attr EPEX_Spot get01-1OExpr round($val,2)
attr EPEX_Spot get01-20Name fc0_19
attr EPEX_Spot get01-20OExpr round($val,2)
attr EPEX_Spot get01-21Name fc0_20
attr EPEX_Spot get01-21OExpr round($val,2)
attr EPEX_Spot get01-22Name fc0_21
attr EPEX_Spot get01-22OExpr round($val,2)
attr EPEX_Spot get01-23Name fc0_22
attr EPEX_Spot get01-23OExpr round($val,2)
attr EPEX_Spot get01-24Name fc0_23
attr EPEX_Spot get01-24OExpr round($val,2)
attr EPEX_Spot get01-2Name fc0_01
attr EPEX_Spot get01-2OExpr round($val,2)
attr EPEX_Spot get01-3Name fc0_02
attr EPEX_Spot get01-3OExpr round($val,2)
attr EPEX_Spot get01-4Name fc0_03
attr EPEX_Spot get01-4OExpr round($val,2)
attr EPEX_Spot get01-5Name fc0_04
attr EPEX_Spot get01-5OExpr round($val,2)
attr EPEX_Spot get01-6Name fc0_05
attr EPEX_Spot get01-6OExpr round($val,2)
attr EPEX_Spot get01-7Name fc0_06
attr EPEX_Spot get01-7OExpr round($val,2)
attr EPEX_Spot get01-8Name fc0_07
attr EPEX_Spot get01-8OExpr round($val,2)
attr EPEX_Spot get01-9Name fc0_08
attr EPEX_Spot get01-9OExpr round($val,2)
attr EPEX_Spot get01Name 01_priceinfo_today
attr EPEX_Spot get01RegOpt g
attr EPEX_Spot get01Regex [price":\[|,](-?\d+\.\d+)
attr EPEX_Spot get01URL https://api.energy-charts.info/price?bzn=DE-LU&start=%%start_today%%
attr EPEX_Spot get02-0Name fc1_00_total
attr EPEX_Spot get02-0OExpr round($val,2)
attr EPEX_Spot get02-10Name fc1_09
attr EPEX_Spot get02-10OExpr round($val,2)
attr EPEX_Spot get02-11Name fc1_10
attr EPEX_Spot get02-11OExpr round($val,2)
attr EPEX_Spot get02-12Name fc1_11
attr EPEX_Spot get02-12OExpr round($val,2)
attr EPEX_Spot get02-13Name fc1_12
attr EPEX_Spot get02-13OExpr round($val,2)
attr EPEX_Spot get02-14Name fc1_13
attr EPEX_Spot get02-14OExpr round($val,2)
attr EPEX_Spot get02-15Name fc1_14
attr EPEX_Spot get02-15OExpr round($val,2)
attr EPEX_Spot get02-16Name fc1_15
attr EPEX_Spot get02-16OExpr round($val,2)
attr EPEX_Spot get02-17Name fc1_16
attr EPEX_Spot get02-17OExpr round($val,2)
attr EPEX_Spot get02-18Name fc1_17
attr EPEX_Spot get02-18OExpr round($val,2)
attr EPEX_Spot get02-19Name fc1_18
attr EPEX_Spot get02-19OExpr round($val,2)
attr EPEX_Spot get02-1Name fc1_00
attr EPEX_Spot get02-1OExpr round($val,2)
attr EPEX_Spot get02-20Name fc1_19
attr EPEX_Spot get02-20OExpr round($val,2)
attr EPEX_Spot get02-21Name fc1_20
attr EPEX_Spot get02-21OExpr round($val,2)
attr EPEX_Spot get02-22Name fc1_21
attr EPEX_Spot get02-22OExpr round($val,2)
attr EPEX_Spot get02-23Name fc1_22
attr EPEX_Spot get02-23OExpr round($val,2)
attr EPEX_Spot get02-24Name fc1_23
attr EPEX_Spot get02-24OExpr round($val,2)
attr EPEX_Spot get02-2Name fc1_01
attr EPEX_Spot get02-2OExpr round($val,2)
attr EPEX_Spot get02-3Name fc1_02
attr EPEX_Spot get02-3OExpr round($val,2)
attr EPEX_Spot get02-4Name fc1_03
attr EPEX_Spot get02-4OExpr round($val,2)
attr EPEX_Spot get02-5Name fc1_04
attr EPEX_Spot get02-5OExpr round($val,2)
attr EPEX_Spot get02-6Name fc1_05
attr EPEX_Spot get02-6OExpr round($val,2)
attr EPEX_Spot get02-7Name fc1_06
attr EPEX_Spot get02-7OExpr round($val,2)
attr EPEX_Spot get02-8Name fc1_07
attr EPEX_Spot get02-8OExpr round($val,2)
attr EPEX_Spot get02-9Name fc1_08
attr EPEX_Spot get02-9OExpr round($val,2)
attr EPEX_Spot get02Name 02_priceinfo_tomorrow
attr EPEX_Spot get02RegOpt g
attr EPEX_Spot get02Regex [price":\[|,](-?\d+\.\d+)
attr EPEX_Spot get02URL https://api.energy-charts.info/price?bzn=DE-LU&start=%%start_tomorrow%%
attr EPEX_Spot group price
attr EPEX_Spot icon stromzaehler_icon
attr EPEX_Spot replacement01Mode expression
attr EPEX_Spot replacement01Regex %%start_today%%
attr EPEX_Spot replacement01Value strftime("%Y-%m-%d",localtime(time))
attr EPEX_Spot replacement02Mode expression
attr EPEX_Spot replacement02Regex %%start_tomorrow%%
attr EPEX_Spot replacement02Value strftime("%Y-%m-%d",localtime(time()+86400))
attr EPEX_Spot room Strom->Boerse
attr EPEX_Spot showBody 1
</syntaxhighlight>

== Links ==
* Website (deutsch) des Anbieters [https://tibber.com/de Tibber]
* Website (deutsch) des Anbieters [https://www.awattar.de/ aWATTar]

Kostal Plenticore 10 Plus

2025-03-17T09:10:46Z

Ch.eick:

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus G1-G3
- Piko MP
- Piko IQ
- Piko CI 30
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatiblen Geräte hier ein.

Anmerkung: Kostal Piko CI 30 mit dem ModbusAttr Modul
Die Modbus-Attribute können zum großen Teil übernommen werden, aber Kostal fängt bei diesem Modell nicht bei "0", sondern bei "1" an zu zählen. Das heißt, alle [https://cdn-production.kostal.com/-/media/document-library-folder---kse/2023/11/20/15/12/ba_kostal-interface-description-modbus_piko-ci.pdf Modbus-Adressen die hier genannt werden], müssen um 1 vermindert werden.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="sql">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+

mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.'dwd_load' TO 'fhemuser'@'%'; <<<< Das beschränkt auf nur eine Prozedure

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+

-- Es könnte auch gut sein einen extra root user anzulegen, um mit DbRep die MySQL Datenbank zu optimieren

mysql> CREATE USER 'fhemroot'@'<IP Adresse>' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> GRANT ALL PRIVILEGES ON `fhem`.* TO 'fhemroot'@'<IP Adresse>' WITH GRANT OPTION;
mysql> GRANT SHOW_ROUTINE ON *.* TO 'fhemroot'@'<IP Adresse>';
mysql> GRANT EXECUTE, CREATE ROUTINE, ALTER ROUTINE ON `fhem`.* TO 'fhemroot'@'<IP Adresse>';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

mysql> SELECT user,host FROM mysql.user;
+------------------+----------------+
| user | host |
+------------------+----------------+
| fhemuser | % |
| fhemroot | 192.168.178.57 | <<< Das sollte man dann auf eine IP einschränken.
| root | localhost |
+------------------+----------------+

-- Hier kann man mal seine Proceduren auflisten
mysql> SHOW PROCEDURE STATUS WHERE Db = 'fhem';

</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy # Version 1.2.18
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wird mit folgenden Parametern aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
</pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2025-03-17T08:55:46Z

Ch.eick: /* KI Prognose Teil 3 - Python KI Prognose Skript */

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="sql">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+

mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.'dwd_load' TO 'fhemuser'@'%'; <<<< Das beschränkt auf nur eine Prozedure

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+

-- Es könnte auch gut sein einen extra root user anzulegen, um mit DbRep die MySQL Datenbank zu optimieren

mysql> CREATE USER 'fhemroot'@'<IP Adresse>' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> GRANT ALL PRIVILEGES ON `fhem`.* TO 'fhemroot'@'<IP Adresse>' WITH GRANT OPTION;
mysql> GRANT SHOW_ROUTINE ON *.* TO 'fhemroot'@'<IP Adresse>';
mysql> GRANT EXECUTE, CREATE ROUTINE, ALTER ROUTINE ON `fhem`.* TO 'fhemroot'@'<IP Adresse>';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

mysql> SELECT user,host FROM mysql.user;
+------------------+----------------+
| user | host |
+------------------+----------------+
| fhemuser | % |
| fhemroot | 192.168.178.57 | <<< Das sollte man dann auf eine IP einschränken.
| root | localhost |
+------------------+----------------+

-- Hier kann man mal seine Proceduren auflisten
mysql> SHOW PROCEDURE STATUS WHERE Db = 'fhem';

</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy # Version 1.2.18
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wird mit folgenden Parametern aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
</pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

OpenWB

2025-01-12T15:57:25Z

Ch.eick: /* Node-red */

== Integration der openWB in FHEM - Ladeleistung anzeigen und Umschalten des Lademodus ==
Ausgangssituation ist ein funktionierendes FHEM, ohne weitere Vorbedingungen.<syntaxhighlight lang="perl">
defmod openwb MQTT <openWBip>:1883
attr openwb room Auto,MQTT

</syntaxhighlight>Dadurch wird der MQTT-Server der openWB angesprochen, FHEM ist der Client.

Ein Ladepunkt wird als MQTT_Device angelegt:<syntaxhighlight lang="perl">
defmod lp1 MQTT_DEVICE
attr lp1 IODev openwb
attr lp1 publishSet_chargeMode openWB/set/ChargeMode
attr lp1 room Auto,Dashboard,MQTT
attr lp1 stateFormat power
attr lp1 subscribeReading_chargeMode openWB/global/ChargeMode
attr lp1 subscribeReading_plugStat openWB/lp/1/boolPlugStat
attr lp1 subscribeReading_power openWB/lp/1/W
</syntaxhighlight>Die Umsetzung basiert auf openWB 1.9.x, der Lademodus "ChargeMode" gilt hier noch global für alle Ladepunkte.

Beispielhaft die Definition des zweiten Ladepunktes, eine zweite openWB, die als "nur Ladepunkt" mit der angesprochenen openWB verbunden ist.

Eine openWB kann derzeit 8 Ladepunkte verwalten, die Nummern müssen entsprechend inkrementiert werden.<syntaxhighlight lang="perl">
defmod lp2 MQTT_DEVICE
attr lp2 IODev openwb
attr lp2 publishSet_chargeMode openWB/set/ChargeMode
attr lp2 room Auto,Dashboard,MQTT
attr lp2 stateFormat power
attr lp2 subscribeReading_chargeMode openWB/global/ChargeMode
attr lp2 subscribeReading_plugStat openWB/lp/2/boolPlugStat
attr lp2 subscribeReading_power openWB/lp/2/W
</syntaxhighlight>Die MQTT-Topics zum Lesen und Schreiben von Werten sind ganz unten auf dieser Wiki-Seite zu finden.

Die Einbindung in die TabletUI sieht bei mir so aus:
[[Datei:Ladepunkte in TabletUI.png|alternativtext=Darstellung der openWB Ladepunkte in der TabletUI|mini|488x488px|Beispielhafte Darstellung in der TabletUI]]
[[Datei:Auswahl des Lademodus.png|alternativtext=Darstellung der openWB Ladepunkte in der TabletUI - Auswahl des Lademodus|mini|486x486px|Auswahl des Lademodus per CircleMenu]]
<syntaxhighlight lang="html">
<div class="cell-60 left-space right-space">
<div data-type="symbol" data-icon="fa-car" class="tall compressed" data-color="lightgray">
<div data-type="circlemenu" data-direction="full" class="mini" style="top: -0.5em;">
<ul class="mini">
<li><div data-type="push" data-device="lp1" data-get="chargeMode" data-states='[0,1,2,3,4]' data-colors='["lightgreen","greenyellow","yellow","grey","black"]' data-icons='["fa-bolt","fa-plus-circle","fa-sun-o","fa-pause-circle-o","fa-stop-circle-o"]' data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="0" data-get-on="0" data-icon="fa-bolt" data-color="lightgreen" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="1" data-get-on="1" data-icon="fa-plus-circle" data-color="greenyellow" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="2" data-get-on="2" data-icon="fa-sun-o" data-color="yellow" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="3" data-get-on="3" data-icon="fa-pause-circle-o" data-color="grey" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="4" data-get-on="4" data-icon="fa-stop-circle-o" data-color="black" data-background-icon=""></div></li>
</ul>
</div>
<div style="font-size: 30% !important;" class="mini " data-pre-text="" data-type="label" data-device="lp1" data-get="power" data-unit="" data-factor="1" data-fix="0"></div>
<div data-type="symbol" data-device="lp1" data-get="plugStat" data-states='[0,1]' data-colors='["white","black"]' data-icons='["","fa-plug"]' data-background-icon="" class="mini" style="font-size: 30% !important; top:1em;"></div></li>
</div>
</div>

</syntaxhighlight>

==Integration OpenWB in FHEM - Übertragung von EVU, PV und Batteriewerten an openWB==
Ausgangssituation ist ein funktionierendes FHEM-System, bei dem bereits der digitale Stromzähler ("Moderne Meßeinrichtung") über das Modul 47_OBIS und der PV-Wechselrichter über ein entsprechendes Modul, z.B. ModbusAttr integriert sind. Als OpenWB-System wurde hier eine reale OpenWB-Wallbox angebunden.

=== Datenquellen ===
Die OpenWB erwartet 1-3 Typen von Datenquellen in dieser Konstellation:
* Die ''EVU-''Schnittstelle, mit der als wesentlicher Steuerparameter der Ladeleistung die Leistungsmessung am Hausübergang herangezogen wird, und daneben die Zählerwerte für Netzbezug und Einspeisung zur Visualisierung übertragen werden sollten. Nur, falls phasenbezogenes Lastmanagement erforderlich sein sollte, sind auch die einzelnen Phasenleistungswerte vom Stromzähler nötig (was nicht jede Moderne Meßeinrichtung auf der OBIS-Schnittstelle bereitstellt)
* Die ''PV-''Schnittstelle, die ebenfalls primär visualisierende Bedeutung hat.
* Die ''Batteriespeicher-''Schnittstelle
OpenWB kann auch z.B. rein mit einer PV-Schnittstelle betrieben werden, in diesem Fall wird ein konstanter Leistungswert für den Hausbezug angenommen.

=== Kommunikationsprotokoll ===
Zur Kommunikation mit FHEM bieten sich 2 Methoden an:
* '''HTTP'''-Abfrage durch OpenWB bei FHEM durch das generische HTTP-Modul von OpenWB Diese Methode beschreibe ich nicht, weil sie mehr Overhead erzeugt und seitens FHEM die Einrichtung eines CSRF-Token-freien Web-Kanals erfordert
* '''MQTT'''-Push durch FHEM zur OpenWB Diese Methode erscheint mir vorteilhafter, weil auf einer stehenden TCP-Verbindung lediglich Meßwerte gepusht werden.

=== Implementierung ===

==== Vorbereitung ====
In der OpenWB-Web-UI unter Modulkonfiguration die entsprechenden Module (EVU, PV, Batterie) auf MQTT stellen. Hinweis: Nicht alle dabei erscheinenden MQTT-Topics müssen mit Werten beliefert werden! Sowohl bei der EVU-Schnittstelle wie bei PV reichen Momentanleistung und Zählerstände für eine zufriedenstellende Anbindung!

==== Definition der OpenWB als MQTT-Target ====
defmod openwb_mqtt MQTT2_CLIENT <ip-der-openwb>:1883
attr openwb_mqtt autocreate simple
attr openwb_mqtt subscriptions openWB/lp/1/#

==== Übertragung der EVU-Meßwerte ====
In diesem Beispiel heißt das die Stromzählerdaten liefernde Device am OBIS-Modul "MT175". Die Zahlen werden per Notify von diesem Device auf MQTT kopiert:
defmod openwb_evu_cons notify MT175:total_consumption:.* { fhem("set openwb_mqtt publish openWB/set/evu/WhImported " . $EVTPART1); }
defmod openwb_evu_feed notify MT175:total_feed:.* { fhem("set openwb_mqtt publish openWB/set/evu/WhExported " . $EVTPART1); }
defmod openwb_evu_w notify MT175:power:.* { fhem("set openwb_mqtt publish openWB/set/evu/W " . int($EVTPART1)); }

==== Übertragung der PV-Meßwerte ====
Sofern die Daten für Momentanleistung und Zählerstand direkt in einem Device vorliegen, können analoge Notifys für dieses Device implementiert werden. Die Zielwerte lauten:
* Für den Momentan-Leistungswert <code>openWB/set/pv/1/W</code>
* Für den Zählerstand <code>openWB/set/pv/1/WhCounter</code>
Dabei muss beachtet werden, dass - wie bei der EVU-Schnittstelle - nur Integerwerte für die Momentanleistung übertragen werden dürfen.

==== Anbindung an Alexa ====
Der generische Smarthome-Skill "FHEMConnector" erlaubt nur die leider immer noch sehr limitierte Syntax von Amazon Alexa. Im Folgenden werden die Definitionen für die Befehle:
* ''"Alexa, schalte Überschussladen ein"''
* ''"Alexa, schalte Überschussladen aus"''
* ''"Alexa, schalte Überschussladen auf 6 (Prozent)"''
dargestellt. "Überschussladen auf 6" bedeutet dabei real den "Min+PV", also Überschussladen mit Minimalleistung von 6 Ampere. Je nach Tagesform von Amazon ist dabei das Sprechen von "Prozent" nötig, auch wenn dies natürlich sachlich falsch ist.
define openwb_ueberschuss dummy
attr openwb_ueberschuss alexaName Überschussladen
attr openwb_ueberschuss genericDeviceType light
attr openwb_ueberschuss readingList pct
attr openwb_ueberschuss setList on off pct
define openwb_ueberschuss_on notify openwb_ueberschuss:on set openwb_mqtt publish openWB/set/ChargeMode 2
define openwb_ueberschuss_off notify openwb_ueberschuss:off set openwb_mqtt publish openWB/set/ChargeMode 3
define openwb_ueberschuss_pct notify openwb_ueberschuss:pct:.* set openwb_mqtt publish openWB/config/set/pv/minCurrentMinPv $EVTPART1 ;; set openwb_mqtt publish openWB/set/ChargeMode 1

==Anwendungs Beispiele==
===Komplexe Anbindung===
[[Bild:Kia.PNG|mini|700px|rechts|WallBox mit Kia Fahrzeug]]
Hier mal ein Beispiel mit weiteren Schnittstellen in der Haussteuerung. Im Hintergrund arbeitet ein Wechselrichter Schwarm mit einem Hausspeicher, der beim BEV Laden gesperrt wird. Die openWB kommuniziert direkt mit den zwei Kostal Wechselrichtern, dem KSEM und dem am Master angeschlossenen Speicher. Das BEV ist über Kia Connect angebunden.
[[Bild:WB_1.PNG|mini|700px|rechts|openWB mit Statistiken]]
[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss, inklusive Wechselrichter, raus kommen. Die openWBs sind unten links.]]
====Verwendete Schnittstellen / Devices====
=====openWB MQTT=====
Wie oben beschrieben mit folgender MQTT definition. Im Bild ist das DOIF dargestellt und das MQTT Device als kurze Darstellung unterhalb der Tabelle. Das MQTT wird nur zur Kopplung verwendet, hat jedoch jetzt auch ein stateFormat inklusieve Statistiken erhalten.

RAW des MQTT Device
<syntaxhighlight lang="Perl">
defmod WB_1 MQTT2_DEVICE WB_1_MQTT2
attr WB_1 DbLogExclude .*
attr WB_1 DbLogInclude lp_1_.*,.*AllChargePoints.*,ChargeMode
attr WB_1 IODev WB_1_MQTT2
attr WB_1 alias WB_1
attr WB_1 autocreate 0
attr WB_1 comment Die openWB besteht aus zwei Ladepunkten.
attr WB_1 devicetopic openWB
attr WB_1 disable 0
attr WB_1 event-on-change-reading lp_1_.*,.*AllChargePoints.*,ChargeMode
attr WB_1 group PV Eigenverbrauch
attr WB_1 icon fuel
attr WB_1 readingList $DEVICETOPIC/global/WHouseConsumption:.* WHouseConsumption\
$DEVICETOPIC/global/WAllChargePoints:.* WAllChargePoints\
$DEVICETOPIC/global/ChargeMode:.* {my %h=(0=>'SofortLaden',1=>'MinPV',2=>'NurPV',3=>'Stop',4=>'Standby');; return {ChargeMode=>$h{$EVENT}}}\
\
$DEVICETOPIC/global/awattar/boolAwattarEnabled:.* boolAwattarEnabled\
$DEVICETOPIC/global/awattar/ActualPriceForCharging:.* ActualPriceForCharging\
$DEVICETOPIC/global/awattar/MaxPriceForCharging:.* MaxPriceForCharging\
$DEVICETOPIC/global/boolRse:.* boolRse\
$DEVICETOPIC/global/DailyYieldAllChargePointsKwh:.* DailyYieldAllChargePointsKwh\
$DEVICETOPIC/global/rfidConfigured:.* rfidConfigured\
$DEVICETOPIC/global/kWhCounterAllChargePoints:.* kWhCounterAllChargePoints\
$DEVICETOPIC/global/strLastmanagementActive:.* strLastmanagementActive\
$DEVICETOPIC/global/ETProvider/modulePath:.* modulePath\
$DEVICETOPIC/global/cpuTemp:.* cpuTemp\
\
$DEVICETOPIC/system/Uptime:.* Uptime\
$DEVICETOPIC/system/Date:.* Date\
$DEVICETOPIC/system/Timestamp:.* Timestamp\
$DEVICETOPIC/system/Version:.* Version\
$DEVICETOPIC/system/IpAddress:.* IpAddress\
$DEVICETOPIC/system/lastRfId:.* lastRfId\
$DEVICETOPIC/system/updateInProgress:.* updateInProgress\
$DEVICETOPIC/system/ConfiguredChargePoints:.* ConfiguredChargePoints\
$DEVICETOPIC/system/lastlivevalues:.* lastlivevalues\
$DEVICETOPIC/system/randomSleep:.* randomSleep\
$DEVICETOPIC/system/wizzardDone:.* wizzardDone\
$DEVICETOPIC/system/priceForKWh:.* priceForKWh\
$DEVICETOPIC/system/reloadDisplay:.* reloadDisplay\
\
$DEVICETOPIC/evu/ASchieflast:.* ASchieflast\
\
$DEVICETOPIC/lp/1/P%Soc:.* lp_1_Pct_Soc\
$DEVICETOPIC/lp/1/%Soc:.* lp_1_current_Soc\
$DEVICETOPIC/lp/1/\x25Soc:.* lp_1__Soc\
\
$DEVICETOPIC/lp/1/countPhasesInUse:.* lp_1_countPhasesInUse\
$DEVICETOPIC/lp/1/ChargePointEnabled:.* lp_1_ChargePointEnabled\
$DEVICETOPIC/lp/1/ChargeStatus:.* lp_1_ChargeStatus\
\
$DEVICETOPIC/lp/1/kWhDailyCharged:.* lp_1_kWhDailyCharged\
$DEVICETOPIC/lp/1/kWhCounter:.* lp_1_kWhCounter\
$DEVICETOPIC/lp/1/kWhActualCharged:.* lp_1_kWhActualCharged\
$DEVICETOPIC/lp/1/kWhChargedSincePlugged:.* lp_1_kWhChargedSincePlugged\
$DEVICETOPIC/lp/1/energyConsumptionPer100km:.* lp_1_energyConsumptionPer100km\
$DEVICETOPIC/lp/1/kmCharged:.* lp_1_kmCharged\
\
$DEVICETOPIC/lp/1/strChargePointName:.* lp_1_strChargePointName\
$DEVICETOPIC/lp/1/TimeRemaining:.* lp_1_TimeRemaining\
\
$DEVICETOPIC/lp/1/PfPhase2:.* lp_1_PfPhase2\
$DEVICETOPIC/lp/1/PfPhase3:.* lp_1_PfPhase3\
$DEVICETOPIC/lp/1/PfPhase1:.* lp_1_PfPhase1\
$DEVICETOPIC/lp/1/W:.* lp_1_W\
\
$DEVICETOPIC/lp/1/boolPlugStat:.* {my %h=(0=>'no Plug',1=>'Plugged in');; return {lp_1_PlugStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/1/boolChargeStat:.* {my %h=(0=>'not loading',1=>'loading');; return {lp_1_ChargeStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/1/AConfigured:.* lp_1_AConfigured\
\
$DEVICETOPIC/lp/1/boolChargePointConfigured:.* lp_1_boolChargePointConfigured\
$DEVICETOPIC/lp/1/boolSocConfigured:.* lp_1_boolSocConfigured\
$DEVICETOPIC/lp/1/boolDirectModeChargekWh:.* lp_1_boolDirectModeChargekWh\
$DEVICETOPIC/lp/1/boolDirectChargeModeSoc:.* lp_1_boolDirectChargeModeSoc\
$DEVICETOPIC/lp/1/boolFinishAtTimeChargeActive:.* lp_1_boolFinishAtTimeChargeActive\
$DEVICETOPIC/lp/1/boolChargeAtNight:.* lp_1_boolChargeAtNight\
$DEVICETOPIC/lp/1/boolSocManual:.* lp_1_boolSocManual\
\
$DEVICETOPIC/lp/1/AutolockStatus:.* lp_1_AutolockStatus\
$DEVICETOPIC/lp/1/AutolockConfigured:.* lp_1_AutolockConfigured\
\
$DEVICETOPIC/lp/1/lastRfId:.* lp_1_lastRfId\
$DEVICETOPIC/lp/1/pluggedladungakt:.* lp_1_pluggedladungakt\
$DEVICETOPIC/lp/1/plugStartkWh:.* lp_1_plugStartkWh\
$DEVICETOPIC/lp/1/MeterSerialNumber:.* lp_1_MeterSerialNumber\
\
\
$DEVICETOPIC/lp/2/P%Soc:.* lp_2_Pct_Soc\
$DEVICETOPIC/lp/2/%Soc:.* lp_2_current_Soc\
$DEVICETOPIC/lp/2/\x25Soc:.* lp_2__Soc\
\
$DEVICETOPIC/lp/2/countPhasesInUse:.* lp_2_countPhasesInUse\
$DEVICETOPIC/lp/2/ChargePointEnabled:.* lp_2_ChargePointEnabled\
$DEVICETOPIC/lp/2/ChargeStatus:.* lp_2_ChargeStatus\
\
$DEVICETOPIC/lp/2/kWhDailyCharged:.* lp_2_kWhDailyCharged\
$DEVICETOPIC/lp/2/kWhCounter:.* lp_2_kWhCounter\
$DEVICETOPIC/lp/2/kWhActualCharged:.* lp_2_kWhActualCharged\
$DEVICETOPIC/lp/2/kWhChargedSincePlugged:.* lp_2_kWhChargedSincePlugged\
$DEVICETOPIC/lp/2/energyConsumptionPer100km:.* lp_2_energyConsumptionPer100km\
$DEVICETOPIC/lp/2/kmCharged:.* lp_2_kmCharged\
\
$DEVICETOPIC/lp/2/strChargePointName:.* lp_2_strChargePointName\
$DEVICETOPIC/lp/2/TimeRemaining:.* lp_2_TimeRemaining\
\
$DEVICETOPIC/lp/2/W:.* lp_2_W\
\
$DEVICETOPIC/lp/2/boolPlugStat:.* {my %h=(0=>'no Plug',1=>'Plugged in');; return {lp_2_PlugStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/2/boolChargeStat:.* {my %h=(0=>'not loading',1=>'loading');; return {lp_2_ChargeStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/2/AConfigured:.* lp_2_AConfigured\
\
$DEVICETOPIC/lp/2/boolChargePointConfigured:.* lp_2_boolChargePointConfigured\
$DEVICETOPIC/lp/2/boolSocConfigured:.* lp_2_boolSocConfigured\
$DEVICETOPIC/lp/2/boolDirectModeChargekWh:.* lp_2_boolDirectModeChargekWh\
$DEVICETOPIC/lp/2/boolDirectChargeModeSoc:.* lp_2_boolDirectChargeModeSoc\
$DEVICETOPIC/lp/2/boolFinishAtTimeChargeActive:.* lp_2_boolFinishAtTimeChargeActive\
$DEVICETOPIC/lp/2/boolChargeAtNight:.* lp_2_boolChargeAtNight\
$DEVICETOPIC/lp/2/boolSocManual:.* lp_2_boolSocManual\
\
$DEVICETOPIC/lp/2/AutolockStatus:.* lp_2_AutolockStatus\
$DEVICETOPIC/lp/2/AutolockConfigured:.* lp_2_AutolockConfigured\
\
$DEVICETOPIC/lp/2/lastRfId:.* lp_2_lastRfId\
$DEVICETOPIC/lp/2/pluggedladungakt:.* lp_2_pluggedladungakt\
$DEVICETOPIC/lp/2/plugStartkWh:.* lp_2_plugStartkWh\
$DEVICETOPIC/lp/2/MeterSerialNumber:.* lp_2_MeterSerialNumber\
\
\
$DEVICETOPIC/boolChargeAtNight_direct:.* boolChargeAtNight_direct\
$DEVICETOPIC/boolChargeAtNight_nurpv:.* boolChargeAtNight_nurpv\
$DEVICETOPIC/boolChargeAtNight_minpv:.* boolChargeAtNight_minpv\
$DEVICETOPIC/boolDisplayHouseConsumption:.* boolDisplayHouseConsumption\
$DEVICETOPIC/boolDisplayDailyCharged:.* boolDisplayDailyCharged\
$DEVICETOPIC/boolEvuSmoothedActive:.* boolEvuSmoothedActive\
$DEVICETOPIC/pv/bool70PVDynActive:.* bool70PVDynActive\
$DEVICETOPIC/pv/W70PVDyn:.* W70PVDyn\
$DEVICETOPIC/pv/bool70PVDynStatus:.* bool70PVDynStatus\
$DEVICETOPIC/pv/CounterTillStartPvCharging:.* CounterTillStartPvCharging\
$DEVICETOPIC/pv/W:.* W\
$DEVICETOPIC/config/get/pv/nurpv70dynact:.* nurpv70dynact\
$DEVICETOPIC/config/get/pv/nurpv70dynw:.* nurpv70dynw\
$DEVICETOPIC/config/get/pv/priorityModeEVBattery:.* priorityModeEVBattery\
$DEVICETOPIC/config/get/pv/lp/1/minSocAlwaysToChargeTo:.* lp_1_minSocAlwaysToChargeTo\
$DEVICETOPIC/config/get/pv/lp/1/maxSoc:.* lp_1_maxSoc\
$DEVICETOPIC/config/get/pv/lp/1/minSocAlwaysToChargeToCurrent:.* lp_1_minSocAlwaysToChargeToCurrent\
$DEVICETOPIC/config/get/pv/lp/1/maxSocToChargeTo:.* lp_1_maxSocToChargeTo\
$DEVICETOPIC/config/get/pv/lp/1/minCurrent:.* lp_1_minCurrent\
$DEVICETOPIC/config/get/pv/lp/1/socLimitation:.* lp_1_socLimitation\
$DEVICETOPIC/config/get/pv/lp/2/minCurrent:.* lp_2_minCurrent\
$DEVICETOPIC/config/get/pv/lp/2/maxSoc:.* lp_2_maxSoc\
$DEVICETOPIC/config/get/pv/lp/2/socLimitation:.* lp_2_socLimitation\
$DEVICETOPIC/config/get/pv/socStopChargeAtMinPv:.* socStopChargeAtMinPv\
$DEVICETOPIC/config/get/pv/regulationPoint:.* regulationPoint\
$DEVICETOPIC/config/get/pv/minBatteryDischargeSocAtBattPriority:.* minBatteryDischargeSocAtBattPriority\
$DEVICETOPIC/config/get/pv/minBatteryChargePowerAtEvPriority:.* minBatteryChargePowerAtEvPriority\
$DEVICETOPIC/config/get/pv/minFeedinPowerBeforeStart:.* minFeedinPowerBeforeStart\
$DEVICETOPIC/config/get/pv/boolAdaptiveCharging:.* boolAdaptiveCharging\
$DEVICETOPIC/config/get/pv/adaptiveChargingFactor:.* adaptiveChargingFactor\
$DEVICETOPIC/config/get/pv/batteryDischargePowerAtBattPriority:.* batteryDischargePowerAtBattPriority\
$DEVICETOPIC/config/get/pv/boolShowPriorityIconInTheme:.* boolShowPriorityIconInTheme\
$DEVICETOPIC/config/get/pv/maxPowerConsumptionBeforeStop:.* maxPowerConsumptionBeforeStop\
$DEVICETOPIC/config/get/pv/stopDelay:.* stopDelay\
$DEVICETOPIC/config/get/pv/chargeSubmode:.* chargeSubmode\
$DEVICETOPIC/config/get/pv/minCurrentMinPv:.* minCurrentMinPv\
$DEVICETOPIC/config/get/pv/socStartChargeAtMinPv:.* socStartChargeAtMinPv\
$DEVICETOPIC/config/get/pv/startDelay:.* startDelay\
$DEVICETOPIC/config/get/sofort/lp/2/energyToCharge:.* lp_2_energyToCharge\
$DEVICETOPIC/config/get/sofort/lp/2/chargeLimitation:.* lp_2_chargeLimitation\
$DEVICETOPIC/config/get/sofort/lp/2/socToChargeTo:.* lp_2_socToChargeTo\
$DEVICETOPIC/config/get/sofort/lp/2/current:.* lp_2_current\
\
$DEVICETOPIC/config/get/sofort/lp/1/socToChargeTo:.* lp_1_socToChargeTo\
\
$DEVICETOPIC/config/get/sofort/lp/1/energyToCharge:.* lp_1_energyToCharge\
$DEVICETOPIC/config/get/sofort/lp/1/chargeLimitation:.* lp_1_chargeLimitation\
$DEVICETOPIC/config/get/sofort/lp/1/current:.* lp_1_current\
$DEVICETOPIC/config/get/global/minEVSECurrentAllowed:.* minEVSECurrentAllowed\
$DEVICETOPIC/config/get/global/maxEVSECurrentAllowed:.* maxEVSECurrentAllowed\
$DEVICETOPIC/config/get/global/dataProtectionAcknoledged:.* dataProtectionAcknoledged\
$DEVICETOPIC/config/get/global/slaveMode:.* slaveMode\
$DEVICETOPIC/config/get/u1p3p/standbyPhases:.* standbyPhases\
$DEVICETOPIC/config/get/u1p3p/sofortPhases:.* sofortPhases\
$DEVICETOPIC/config/get/u1p3p/nachtPhases:.* nachtPhases\
$DEVICETOPIC/config/get/u1p3p/minundpvPhases:.* minundpvPhases\
$DEVICETOPIC/config/get/u1p3p/nurpvPhases:.* nurpvPhases\
$DEVICETOPIC/config/get/u1p3p/isConfigured:.* isConfigured\
$DEVICETOPIC/boolChargeAtNight_standby:.* boolChargeAtNight_standby\
$DEVICETOPIC/set/system/reloadDisplay:.* reloadDisplay\
$DEVICETOPIC/set/system/topicSender:.* topicSender\
$DEVICETOPIC/set/lp/2/faultState:.* lp_2_faultState\
$DEVICETOPIC/set/lp/2/faultStr:.* lp_2_faultStr\
$DEVICETOPIC/set/lp/2/ChargePointEnabled:.* lp_2_ChargePointEnabled
attr WB_1 room MQTT2_DEVICE,Strom->Photovoltaik
attr WB_1 setList Lademodus:SofortLaden,Min+PV,NurPV,Stop,Standby { my %h=(SofortLaden=>'0','Min+PV'=>'1',NurPV=>'2',Stop=>'3',Standby=>'4');;qq($DEVICETOPIC/set/ChargeMode $h{$EVTPART1}) }\
DirectChargeSubMode:Aus,kWh_Laden,SoC_Laden { my %h=(Aus=>'0',kWh_Laden=>'1',SoC_Laden=>'2');;qq($DEVICETOPIC/set/lp1/DirectChargeSubMode $h{$EVTPART1}) }\
lp_1_socToChargeTo:50,60,70,80,90,100 { qq($DEVICETOPIC/config/set/sofort/lp/1/socToChargeTo $EVTPART1) }
attr WB_1 sortby 311
attr WB_1 stateFormat {\
my $YearBefore='LogDBRep_Statistic_previous_Year';;\
my $DUMMY = "";;\
my $date = POSIX::strftime("%Y-%m-%d",localtime(time_str2num(ReadingsTimestamp($name, "lastlivevalues",0))));;\
\
my $ChargeMode = ReadingsVal($name,"ChargeMode","n/a");;\
$ChargeMode = ($ChargeMode eq "SofortLaden")? "SofortLaden" : ($ChargeMode eq "MinPV")? "Min+PV" : ($ChargeMode eq "NurPV")? "NurPV" : $ChargeMode;;\
\
my $lp_1_Name = ReadingsVal($name,"lp_1_strChargePointName","n/a");;\
my $lp_1_Power = ReadingsVal($name,"lp_1_W",0)." W";;\
my $lp_1_Power_1 = ReadingsVal($name,"lp_1_countPhasesInUse",0)."P ".ReadingsVal($name,"lp_1_AConfigured",0)."A";;\
my $lp_1_Status_1 = ReadingsVal($name,"lp_1_PlugStat","n/a")." ".ReadingsVal($name,"lp_1_ChargeStat","n/a");;\
my $lp_1_Status_2 = ReadingsVal($name,"lp_1_TimeRemaining","n/a");;\
\
my $lp_1_Power_d = ReadingsVal($name,"lp_1_kWhDailyCharged",0)." kWh";;\
my $lp_1_Power_m = round(ReadingsVal($name,"lp_1_kWhCounter_Month",0),0)." kWh";;\
my $lp_1_Power_j = sprintf("%04d / %04d",ReadingsVal($name,"lp_1_kWhCounter_Year",0),ReadingsVal($YearBefore,"lp_1_kWhCounter_Year",0));;\
my $lp_1_Power_t = round(ReadingsVal($name,"lp_1_kWhCounter",0),0)." kWh";;\
\
my $lp_2_Name = ReadingsVal($name,"lp_2_strChargePointName","n/a");;\
my $lp_2_Power = ReadingsVal($name,"lp_2_W",0)." W";;\
my $lp_2_Power_1 = ReadingsVal($name,"lp_2_countPhasesInUse",0)."P ".ReadingsVal($name,"lp_2_AConfigured",0)."A";;\
my $lp_2_Status_1 = ReadingsVal($name,"lp_2_PlugStat","n/a")." ".ReadingsVal($name,"lp_2_ChargeStat","n/a");;\
my $lp_2_Status_2 = " ".ReadingsVal($name,"lp_2_TimeRemaining","n/a");;\
\
my $lp_2_Power_d = ReadingsVal($name,"lp_2_kWhDailyCharged",0)." kWh";;\
my $lp_2_Power_m = round(ReadingsVal($name,"lp_2_kWhCounter_Month",0),0)." kWh";;\
my $lp_2_Power_j = sprintf("%04d / %04d",ReadingsVal($name,"lp_2_kWhCounter_Year",0),ReadingsVal($YearBefore,"lp_2_kWhCounter_Year",0));;\
my $lp_2_Power_t = round(ReadingsVal($name,"lp_2_kWhCounter",0),0)." kWh";;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 52%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
</colgroup>\
<tr><td style='padding-right:5px;;padding-left:5px;;font-weight:bold'>Wallbox</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>$ChargeMode</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Status</td><td style='padding-right:5px;;padding-left:5px;;text-align:center;;font-weight:bold'>Restladezeit</td><td style='padding-right:5px;;padding-left:5px;;text-align:center;;font-weight:bold'>Leistung</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_1_Name."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$DUMMY."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Status_1."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Status_2." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_1." ".$lp_1_Power."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_2_Name."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$DUMMY."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Status_1."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Status_2." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_1." ".$lp_2_Power."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;font-weight:bold'>Statistik vom $date</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>aktuell</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Heute</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Monat</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Jahr/Vorjahr</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_1_Name."<td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_d."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_m." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_j."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_2_Name."<td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_d."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_m." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_j."</td></tr>\
</table>\
</html>"\
}
attr WB_1 userReadings lp_1_kWhCounter_Month:lp_1_kWhCounter.* { round(ReadingsVal("$NAME","lp_1_kWhCounter",0) - ReadingsVal("$NAME","lp_1_kWhCounter_init_Month",0),0) },\
lp_1_kWhCounter_Year:lp_1_kWhCounter.* { round(ReadingsVal("$NAME","lp_1_kWhCounter",0) - ReadingsVal("$NAME","lp_1_kWhCounter_init_Year",0),0) },\
\
lp_2_kWhCounter_Month:lp_2_kWhCounter.* { round(ReadingsVal("$NAME","lp_2_kWhCounter",0) - ReadingsVal("$NAME","lp_2_kWhCounter_init_Month",0),0) },\
lp_2_kWhCounter_Year:lp_2_kWhCounter.* { round(ReadingsVal("$NAME","lp_2_kWhCounter",0) - ReadingsVal("$NAME","lp_2_kWhCounter_init_Year",0),0) }
</syntaxhighlight>

=====Kia connect MQTT=====
Das Kia_connect Device empfängt und sendet die MQTT Nachrichten zum Node-red Flow für das Kia BEV.

RAW des Kia connect
<syntaxhighlight lang="Perl">
defmod Kia_connect MQTT2_DEVICE
attr Kia_connect DbLogExclude .*
attr Kia_connect DbLogInclude .*
attr Kia_connect IODev MQTT2_FHEM_Server
attr Kia_connect alias Kia_connect
attr Kia_connect autocreate 1
attr Kia_connect devicetopic bluelinky
attr Kia_connect group PV Eigenverbrauch-Steuerung
attr Kia_connect icon car
attr Kia_connect readingList $DEVICETOPIC/status:.* { json2nameValue($EVENT) }\
$DEVICETOPIC/location.* { json2nameValue($EVENT) }\
$DEVICETOPIC/odometer:.* { json2nameValue($EVENT) }\
$DEVICETOPIC/req_received:.* req_received\
$DEVICETOPIC/req_active:.* req_active
attr Kia_connect room MQTT2_DEVICE,Strom->Photovoltaik
attr Kia_connect setList getOdometer req/$DEVICETOPIC/get_odometer get_odometer\
getStatus req/$DEVICETOPIC/get_status get_status\
getLocation req/$DEVICETOPIC/get_location get_location\
getTripinfo req/$DEVICETOPIC/get_tripinfo\
getAll req/$DEVICETOPIC/get_all get_all\
setChargeTargetSoc req/$DEVICETOPIC/set_chargetargets\
startCharge req/$DEVICETOPIC/start_charging start_charging\
stopCharge req/$DEVICETOPIC/stop_charging stop_charging\
stopClimate req/$DEVICETOPIC/stop_climate stop_climate\
startClimate req/$DEVICETOPIC/start_climate
attr Kia_connect sortby 402
attr Kia_connect stateFormat req_active
attr Kia_connect userReadings atHomeStanding:location.* { ((abs(AttrVal("global","latitude",49.85) - ReadingsVal($NAME,"location_coord_lat",0)) <= 0.001) && (abs(AttrVal("global","longitude",8.49) - ReadingsVal($NAME,"location_coord_lon",0)) <= 0.001) && (ReadingsVal($NAME,"location_speed_value",1) == 0)) ? 'true' : 'false';;;; },\
batSOC:status.* { ReadingsVal($NAME,"status_evStatus_batteryStatus",0);;;;},\
connected:status.* { (ReadingsVal($NAME,"status_evStatus_batteryPlugin",0) != 0) ? 'true' : 'false';;;;},\
charging:status.* { ReadingsVal($NAME,"status_evStatus_batteryCharge",'false');;;;},\
targetSOC:status.* { ReadingsVal($NAME,"status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel",0);;;;},\
time2targetSOC:status.* { my $t = ReadingsVal($NAME,"status_evStatus_remainTime2_atc_value",1);;;; sprintf("%02d:%02d", $t/60%60, $t%60);;},\
range:status.* { ReadingsVal($NAME,"status_evStatus_drvDistance_1_rangeByFuel_totalAvailableRange_value",0);;;;},\
bat12v:status.* { ReadingsVal($NAME,"status_battery_batSoc",0);;;;}
</syntaxhighlight>

=====Node-red=====
[[Bild:Kia Flow.PNG|mini|900px|rechts|Node-red Kia Flow]]
Node-red habe ich einfach in einem Docker Container runter geladen und gestartet. Über Port 1880 kommt man direkt in die GUI und kann den ersten Flow laden.

docker-compose .yml Eintrag
<syntaxhighlight lang="Perl">
node-red:
image: nodered/node-red:latest
restart: always
environment:
- TZ=Europe/Berlin
ports:
- 1880:1880
volumes:
- ./node-red/data:/data
</syntaxhighlight>

Danach fehlt im Container noch folgende Erweiterung für den Node-red Flow
<syntaxhighlight lang="Perl">
npm install node-red-contrib-bluelinky
</syntaxhighlight>

Im Node-red Kia Flow muss für MQTT dann noch der Benutzer und das Passwort abgelegt werden. Ansonst kommt nämlich im FHEM nichts an.

=====Kia Connect=====
<pre>
Kia connect ist eine API für Kia und Hyundai E-Autos mit der man Daten vom Auto abfragen kann und auch einige Steuerungen möglich sind.
Mit Node-red und BlueLinky wird die Schnittstelle bedient.
Der Flow ist nicht ursprünglich von mir, wurde jedoch noch erweitert.
Vor dem Laden des Flows sind noch die persönlichen Verbindungsdaten im JSON einzutragen.

Nach dem Laden ist ein Test mit den Inject Symbolen und der Debug Funktionalität möglich und auch sinnvoll.
Unterhalb der MQTT - und BlueLinky Symbole sollte "Verbunden" oder "Ready" erscheinen.
</pre>
'''Wichtig beim Kia ist, dass für das Laden über die openWB als SOC Ziel 80% im standard Modus konfiguriert wird.''' Ansonsten wundert man sich warum das Laden einfach nicht starten möchte. Im Default ist dort bei mir nur 50% eingetragen gewesen :-). Mit jetzt 100% kann die openWB auch selber einen Ziel SOC bestimmen, ansonsten hört das BEV einfach selber auf zu laden.

Weiterhin sollte man darauf achten, dass man nur eine begrenzte Anzahl von Nachrichten mit dem Kia BEV pro Tag austauschen kann. Das wurde im DOIF schon etwas berücksichtigt (1x pro Stunde), kann jedoch bei gleichzeitiger Verwendung der Handy App oder der SOC Abfrage im openWB Kia Modul auch mal zu Fehlern führen. Durch die Stündliche Status Abfrage im DOIF kommt es natürlich zu Verzögerungen im FHEM Status. Dann einfach einmal Manuell abfragen.

Node-red JSON Import
<syntaxhighlight lang="json">
[ {
"id": "866c75dd.edd9a8",
"type": "tab",
"label": "Kia e-Niro",
"disabled": false,
"info": ""
},
{
"id": "bb13a99d.68b8f8",
"type": "mqtt-broker",
"name": "mqtt_Server",
"broker": "<FHEM MQTT IP Adresse>",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"compatmode": false,
"protocolVersion": "4",
"keepalive": "60",
"cleansession": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"sessionExpiry": ""
},
{
"id": "452a3304.58c8fc",
"type": "bluelinky",
"username": "<Mail Adresse bei Kia>",
"password": "<Passwort>",
"region": "EU",
"pin": "<Pin>",
"vin": "<VIN>",
"brand": "kia"
},
{
"id": "91a345fa.5757a8",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_status",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 260,
"y": 280,
"wires": [
[
"15dfb508.c6497b",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "5ad085b9.05739c",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/start_climate",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 680,
"wires": [
[
"b27d74de.38c808",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "15dfb508.c6497b",
"type": "car-status",
"z": "866c75dd.edd9a8",
"name": "Get status",
"dorefresh": true,
"parsed": false,
"bluelinky": "452a3304.58c8fc",
"x": 1110,
"y": 280,
"wires": [
[
"cccc9476.d56dd8",
"226ed925.607bb6"
]
]
},
{
"id": "87abdd88.8ff4d",
"type": "car-odometer",
"z": "866c75dd.edd9a8",
"name": "Get car odometer",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 200,
"wires": [
[
"40d2361c.579588",
"226ed925.607bb6"
]
]
},
{
"id": "31100f9a.40008",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "locationWrapper",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"location\": msg.payload,\n \"error\": false\n };\n \n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 1490,
"y": 120,
"wires": [
[
"85a07155.a0f9f",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "bea1d927.0f3908",
"type": "car-location",
"z": "866c75dd.edd9a8",
"name": "Get car location",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 120,
"wires": [
[
"31100f9a.40008",
"226ed925.607bb6"
]
]
},
{
"id": "3c949d67.0d83b2",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_location",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 120,
"wires": [
[
"bea1d927.0f3908",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "cccc9476.d56dd8",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "analyseStatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n let status = msg.payload;\n status.airTemp.value = 14+(parseInt(status.airTemp.value,16)/2);\n try{\n status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n } catch(e) {}\n\n let time = status.evStatus.remainTime2.atc.value/60;\n let result = { \n \"batSOC\": status.evStatus.batteryStatus,\n \"connected\": (status.evStatus.batteryPlugin !== 0),\n \"charging\": status.evStatus.batteryCharge,\n \"targetSOC\": status.evStatus.reservChargeInfos.targetSOClist[1].targetSOClevel,\n \"time2targetSOC\": (Math.floor(time) + \":\" + (\"0\" + Math.floor((time % 1)*60)).slice(-2)), // h:mm\n \"range\": status.evStatus.drvDistance[0].rangeByFuel.totalAvailableRange.value,\n \"bat12v\": status.battery.batSoc\n };\n \n //msg.payload = result;\n msg.payload = {\n \"status\": status,\n \"error\": false\n \n };\n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1480,
"y": 280,
"wires": [
[
"3efceea0.c81b12",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "85a07155.a0f9f",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/location",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1910,
"y": 120,
"wires": []
},
{
"id": "3efceea0.c81b12",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/status",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1900,
"y": 280,
"wires": []
},
{
"id": "327104fc.71e1bc",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/odometer",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1910,
"y": 200,
"wires": []
},
{
"id": "844a32f4.2e029",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/stop_climate",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 270,
"y": 760,
"wires": [
[
"7d3ae860.d8c9a8",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "57d91e50.7e96",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/start_charging",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 280,
"y": 820,
"wires": [
[
"6eebc52c.ee23dc",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "6029f0a0.b73e",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/stop_charging",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 280,
"y": 880,
"wires": [
[
"84a1ae.74912e5",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "c5ecf76c.e753c8",
"type": "start-car",
"z": "866c75dd.edd9a8",
"name": "Start car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 680,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "6eebc52c.ee23dc",
"type": "start-charge",
"z": "866c75dd.edd9a8",
"name": "Start Charging",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 820,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "84a1ae.74912e5",
"type": "stop-charge",
"z": "866c75dd.edd9a8",
"name": "Stop Charging",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 880,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "7d3ae860.d8c9a8",
"type": "stop-car",
"z": "866c75dd.edd9a8",
"name": "Stop car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 760,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "b27d74de.38c808",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "obj",
"pretty": false,
"x": 750,
"y": 680,
"wires": [
[
"c5ecf76c.e753c8",
"33b1bc85.662694"
]
]
},
{
"id": "45a6a8e6.2abfd8",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_odometer",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 280,
"y": 200,
"wires": [
[
"87abdd88.8ff4d",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "33b1bc85.662694",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 930,
"y": 920,
"wires": []
},
{
"id": "ce62ba4f.d86548",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/req_received",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 860,
"y": 480,
"wires": []
},
{
"id": "1babee6c.1c2982",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_all",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 250,
"y": 360,
"wires": [
[
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2",
"4375fbb9.00fb44"
]
]
},
{
"id": "262df5dc.57916a",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1850,
"y": 80,
"wires": []
},
{
"id": "811aa567.e89f98",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1470,
"y": 1040,
"wires": []
},
{
"id": "3f82a275.5a0b6e",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 930,
"y": 80,
"wires": []
},
{
"id": "24d5e0b.3aafc2",
"type": "change",
"z": "866c75dd.edd9a8",
"name": "",
"rules": [
{
"t": "set",
"p": "payload",
"pt": "msg",
"to": "pending",
"tot": "str"
}
],
"action": "",
"property": "",
"from": "",
"to": "",
"reg": false,
"x": 790,
"y": 1140,
"wires": [
[
"4dd1ea4a.52f144",
"fecad185.324f8"
]
]
},
{
"id": "f487d6d6.a4d568",
"type": "change",
"z": "866c75dd.edd9a8",
"name": "",
"rules": [
{
"t": "set",
"p": "payload",
"pt": "msg",
"to": "idle",
"tot": "str"
}
],
"action": "",
"property": "",
"from": "",
"to": "",
"reg": false,
"x": 1910,
"y": 760,
"wires": [
[
"4dd1ea4a.52f144",
"fecad185.324f8"
]
]
},
{
"id": "4dd1ea4a.52f144",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/req_active",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 2140,
"y": 1100,
"wires": []
},
{
"id": "fecad185.324f8",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "false",
"statusVal": "",
"statusType": "auto",
"x": 2110,
"y": 1160,
"wires": []
},
{
"id": "40d2361c.579588",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "odometerWrapper",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n msg.payload = { \n \"odometer\": msg.payload,\n \"error\": false\n };\n\n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 1490,
"y": 200,
"wires": [
[
"327104fc.71e1bc",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "226ed925.607bb6",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1430,
"y": 80,
"wires": []
},
{
"id": "4375fbb9.00fb44",
"type": "car-fullstatus",
"z": "866c75dd.edd9a8",
"name": "Get full status",
"dorefresh": true,
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 360,
"wires": [
[
"226ed925.607bb6",
"69b6c4df.ea6bcc",
"89681a97.9e24d8",
"92dc3ff4.1d6e3"
]
]
},
{
"id": "69b6c4df.ea6bcc",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "locationFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"location\": msg.payload.vehicleLocation,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1500,
"y": 360,
"wires": [
[
"85a07155.a0f9f",
"331e5860.907808"
]
]
},
{
"id": "92dc3ff4.1d6e3",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "statusFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n let status = msg.payload.vehicleStatus;\n try{\n status.airTemp.value = 14+(parseInt(status.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n } catch(e) {}\n\n msg.payload = { \n \"status\": status,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1500,
"y": 480,
"wires": [
[
"3efceea0.c81b12",
"f487d6d6.a4d568",
"331e5860.907808"
]
]
},
{
"id": "89681a97.9e24d8",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "odometerFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"odometer\": msg.payload.odometer,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1510,
"y": 420,
"wires": [
[
"327104fc.71e1bc",
"331e5860.907808"
]
]
},
{
"id": "331e5860.907808",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1850,
"y": 520,
"wires": []
},
{
"id": "aa4d220b.f7e19",
"type": "set-chargetargets",
"z": "866c75dd.edd9a8",
"name": "Set charge targets",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 960,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "4c03338d.2f15ec",
"type": "login",
"z": "866c75dd.edd9a8",
"name": "Login",
"bluelinky": "452a3304.58c8fc",
"x": 1090,
"y": 1040,
"wires": [
[
"811aa567.e89f98"
]
]
},
{
"id": "28b868f5.16cb48",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "43200",
"crontab": "",
"once": true,
"onceDelay": "12",
"topic": "",
"payloadType": "date",
"x": 950,
"y": 1040,
"wires": [
[
"4c03338d.2f15ec"
]
]
},
{
"id": "db9ecdb5.a9683",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/set_chargetargets",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 290,
"y": 960,
"wires": [
[
"7064a8d53256b646",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "44155ad70c47b0dd",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 260,
"wires": [
[
"15dfb508.c6497b"
]
]
},
{
"id": "7064a8d53256b646",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "obj",
"pretty": false,
"x": 750,
"y": 960,
"wires": [
[
"33b1bc85.662694",
"aa4d220b.f7e19"
]
]
},
{
"id": "7064395e56292844",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 340,
"wires": [
[
"4375fbb9.00fb44"
]
]
},
{
"id": "5f9ff828080f5fe6",
"type": "lock-car",
"z": "866c75dd.edd9a8",
"name": "Lock car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 560,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "492f5b94a865e47b",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 540,
"wires": [
[
"5f9ff828080f5fe6"
]
]
},
{
"id": "d6f3f148e765caf9",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/car_lock",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 260,
"y": 560,
"wires": [
[
"5f9ff828080f5fe6",
"ce62ba4f.d86548"
]
]
},
{
"id": "cdc13a486db22b8e",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/car_unlock",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 620,
"wires": [
[
"99f5c3a41ac3e754",
"ce62ba4f.d86548"
]
]
},
{
"id": "99f5c3a41ac3e754",
"type": "unlock-car",
"z": "866c75dd.edd9a8",
"name": "Unlock car",
"bluelinky": "452a3304.58c8fc",
"x": 1110,
"y": 620,
"wires": [
[
"f487d6d6.a4d568",
"811aa567.e89f98"
]
]
},
{
"id": "ab557a0ea621403a",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 600,
"wires": [
[
"99f5c3a41ac3e754"
]
]
},
{
"id": "a525de86e4374518",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 740,
"wires": [
[
"7d3ae860.d8c9a8"
]
]
},
{
"id": "0b8cb92c042fe140",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 800,
"wires": [
[
"6eebc52c.ee23dc"
]
]
},
{
"id": "ae4c2139b08aaa28",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 860,
"wires": [
[
"84a1ae.74912e5"
]
]
},
{
"id": "dd23108ce63f456d",
"type": "get-monthlyreport",
"z": "866c75dd.edd9a8",
"name": "Get monthly report",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 1280,
"wires": [
[
"e57eb97531129426"
]
]
},
{
"id": "a6e5e8deb52145f1",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 1260,
"wires": [
[
"dd23108ce63f456d"
]
]
},
{
"id": "95f1b6f32aafd65b",
"type": "get-tripinfo",
"z": "866c75dd.edd9a8",
"name": "Tripinfo",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 1220,
"wires": [
[
"e57eb97531129426"
]
]
},
{
"id": "fb2b99958bc48593",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "",
"pretty": false,
"x": 750,
"y": 1220,
"wires": [
[
"95f1b6f32aafd65b"
]
]
},
{
"id": "5230ebe391325b17",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_tripinfo",
"qos": "2",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 270,
"y": 1220,
"wires": [
[
"fb2b99958bc48593"
]
]
},
{
"id": "e57eb97531129426",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1470,
"y": 1220,
"wires": []
},
{
"id": "4fdf3b1b7811c89f",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_tripinfo",
"qos": "2",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 270,
"y": 1280,
"wires": [
[
"dd23108ce63f456d"
]
]
}
]
</syntaxhighlight>

=====Kia_eNiro_PV DOIF mit uiTable=====
Mit diesem DOIF Device werden folgende Funktionalitäten abgebildet:
Nun dann noch das DOIF mit dem uiTable für die Status Anzeige und die Steuerung über Pull Down Menüs.

- Status Abfrage
Status jede Stunde zwischen 6 und 23 Uhr (12V min 40%)
Status beim Laden alle 15 Minuten (12V min 40%)
Anzeige des Kilometerzählers
Status des Fahrzeuges zu Hause / unterwegs und beim Laden
Fahrzeug Auf/Zu

- Klimatisierung über das Pull Down Menü
unterschiedliche Temperaturen für Heizen und Kühlen
Aktuelle Temperatur
Heizen/Klima Ein/Aus
Timer für zeitgesteuertes Klimatisieren für den Resttag oder den Nächsten Tag (vor der aktuellen Zeit)
Klimatisierung über "Abfall" Kalender (es geht nur ein Termin pro Tag, dafür aber komfortabel über das Handy)

- Komfort
Reifen Überwachung
Türen / Motorhaube / Kofferraum Überwachung
12V Batterie anzeige, wenn der Ladezustand kleiner 40% ist erfolgt keine weitere Status Abfrage

- ACCU Steuerung
Setzen des Ziel SOC beim Standard Laden
Start/Stop Laden
Accu Stand und berechnete Restkilometer

- Für openWB integratin im uiTable
Wählen des Lademodus
Vorrang EV oder Bat
Sperren des Hausspeichers entweder manuell oder automatisch beim Laden. Der vorherige Zustand wird gespeichert
Die Freigabe erfolgt über die Wechselrichter Implementierung, siehe dort [[Kostal_Plenticore_10_Plus#Externe_Speichersteuerung_.28ExternControl.29|"Externe Speicher Steuerung"]]
Geschätzte Ladezeit
Status Ladepunkt (Plug und Laden)
Lade Status Phasen und Leistung

'''Achtung, die Kia connect Abfragen sind auf ca. 200 pro Tag von Kia limitiert! Durch die Stündliche Status Abfrage im DOIF kommt es natürlich zu Verzögerungen im FHEM Status. Dann einfach einmal manuell abfragen.'''

Die Kommunikation zum Kia BEV ist manchmal sehr träge, z.B. kann eine Status Abfrage auch mal 3 Minuten dauern, deshalb wurde eine Verriegelung implementiert. Es wird ein Status pending/idle angezeigt. Nur wenn der Zustand "idel" ist, können weitere Abfragen gestartet werden. Läuft z.B. die Status Abfrage kann man ein weiteres Kommando anstarten, es wird jedoch erst abgesetzt, wenn das vorherige Kommando fertig ist. Solange bleibt im Pull Down Menü das neue Kommando stehen.

RAW des DOIF
<syntaxhighlight lang="Perl">
defmod Kia_eNiro_PV DOIF ################################################################################################################\
## 1 Kia Connect Status Abfrage erfolgt mit MQTT2 ==> node-ret ==> Kia Connect\
##\
1_Status_getAll\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( ([+00:15] and ## alle 15 Minuten\
[Kia_connect:atHomeStanding] eq "true" and ## wenn das Auto zuhause ist\
[Kia_connect:charging] eq "true" or ## und es geladen wird\
[:58] and [05:00-23:00] ## ansonsten nur jede Stunde\
) and [Kia_connect:bat12v] > 40 ## aber die 12V Batterie sollte noch genügend Ladung haben\
or [$SELF:cmd_event] eq "set_cmd_1" ## Das reagiert auf den Aufruf mit "set <Device> cmd_*"\
or [$SELF:ui_command_1] eq "Status_getAll" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "Status_getAll" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_before_1",[$SELF:ui_command_1]);;\
}\
\
fhem_set("Kia_connect getAll");; ## beliebige Kommandos für diesen Block\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
2_Klima\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_2] eq "stopClimate" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_2] eq "startHeating"\
or [$SELF:ui_command_2] eq "startCooling"\
)\
) {\
set_Reading("ui_command_before_2",[$SELF:ui_command_2]);;\
\
if ([$SELF:ui_command_2] eq "startHeating") {\
my $airTemp_value= [Kia_connect:status_airTemp_value_target_Winter];;\
fhem_set('Kia_connect startClimate {"defrost": true, "windscreenHeating": true, "temperature": '.$airTemp_value.' , "unit": "C"}');;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : startHeating"};;\
}\
if ([$SELF:ui_command_2] eq "startCooling") {\
my $airTemp_value = [Kia_connect:status_airTemp_value_target_Summer];;\
fhem_set('Kia_connect startClimate {"defrost": false, "windscreenHeating": false, "temperature": '.$airTemp_value.' , "unit": "C"}');;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : startCooling"};;\
}\
if ([$SELF:ui_command_2] eq "stopClimate") {\
fhem_set("Kia_connect ".[$SELF:ui_command_2]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : stopClimate"};;\
}\
fhem_set("Abfall update");;\
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
3_Laden\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_3] eq "setChargeTargetSoc" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_3] eq "startCharge"\
or [$SELF:ui_command_3] eq "stopCharge"\
)\
) {\
set_Reading("ui_command_before_3",[$SELF:ui_command_3]);;\
\
if ([$SELF:ui_command_3] eq "setChargeTargetSoc") {\
my $targetSOClist_1_targetSOClevel = [Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_1_targetSOClevel_target];;\
my $targetSOClist_2_targetSOClevel = [Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel_target];;\
fhem_set("Kia_connect setChargeTargetSoc {\"fast\": ".$targetSOClist_1_targetSOClevel.", \"slow\": ".$targetSOClist_2_targetSOClevel."}");;\
} else {\
fhem_set("Kia_connect ".[$SELF:ui_command_3]);; ## beliebige Kommandos für diesen Block\
}\
\
set_Reading("ui_command_3","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
4_Klima_timer_heizen\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [[Abfall_Abfuhr:Kiaheizen_connect_time]] ## Prüfe den Kalender Eintrag\
and [Abfall_Abfuhr:Kiaheizen_connect_date] eq $ymd ## ist es heute?\
)\
or\
( [$SELF:ui_timer_mode] eq "heizen" ## Timer zum Heizen aktiv?\
and [[$SELF:ui_timer_Start]] ## ist es soweit?\
)\
)\
) {\
\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 4_Klima_timer : startHeating"};;\
set_Reading("ui_timer_mode","Aus");; ## Schalte die Timer Funktion ab\
set_Reading("ui_command_2","startHeating");; ## Es soll geheizt werden\
fhem_set("$SELF 2_Klima");; ## Aktiviere das Heizen\
\
}\
}\
\
5_Klima_timer_kuehlen\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [[Abfall_Abfuhr:Kiakuehlen_connect_time]] ## Prüfe den Kalender Eintrag\
and [Abfall_Abfuhr:Kiakuehlen_connect_date] eq $ymd ## ist es heute?\
)\
or\
( [$SELF:ui_timer_mode] eq "kuehlen" ## Timer zum Kühler aktiv?\
and [[$SELF:ui_timer_Start]] ## ist es soweit?\
)\
)\
) {\
\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 4_Klima_timer : startCooling"};;\
set_Reading("ui_timer_mode","Aus");; ## Schalte die Timer Funktion ab\
set_Reading("ui_command_2","startCooling");; ## Es soll gekühlt werden\
fhem_set("$SELF 2_Klima");; ## Aktiviere das Kühlen\
\
}\
}\
\
6_Auf_Zu\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_2] eq "car_lock" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_2] eq "car_unlock"\
)\
) {\
set_Reading("ui_command_before_2",[$SELF:ui_command_2]);;\
\
fhem_set("Kia_connect ".[$SELF:ui_command_2]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 6_Auf_Zu : ".[$SELF:ui_command_2]};;\
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
7_WB_1_lp_1\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:ui_command_4] eq "SofortLaden" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_4] eq "Min+PV"\
or [$SELF:ui_command_4] eq "NurPV"\
or [$SELF:ui_command_4] eq "Stop"\
or [$SELF:ui_command_4] eq "Standby"\
or [$SELF:ui_command_4] eq "Vorrang_EV"\
or [$SELF:ui_command_4] eq "Vorrang_Bat"\
)\
) {\
set_Reading("ui_command_before_4",[$SELF:ui_command_4]);;\
\
if ([$SELF:ui_command_4] eq "Vorrang_Bat" or [$SELF:ui_command_4] eq "Vorrang_EV") {\
if ([$SELF:ui_command_4] eq "Vorrang_EV") {\
fhem_set("WB_1 priorityModeEVBattery 1");;\
} else {\
fhem_set("WB_1 priorityModeEVBattery 0");;\
}\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 7_WB_1_lp_1 : ".[$SELF:ui_command_4]};;\
} else {\
fhem_set("WB_1 Lademodus ".[$SELF:ui_command_4]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 7_WB_1_lp_1 : Lademodus ".[$SELF:ui_command_4]};;\
}\
\
set_Reading("ui_command_4","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
8_Speicher_sperren\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:ui_command_4] eq "Hausspeicher_Sperren" ## Hier wird das uiTable select ausgewertet\
or [WB_1:lp_1_ChargeStat] eq "loading" and\
[WB_1:lp_1_PlugStat] eq "Plugged in"\
)\
) {\
set_Reading("ui_command_before_4",[$SELF:ui_command_4]);;\
\
if([$SELF:WR_1_Speicher_1_ExternControl_smart_laden_before] eq "---") {\
\
if([$SELF:SpeicherExternTrigger] eq "gesperrt" and\
[WR_1_API:Battery_InternControl_MinHomeConsumption] eq "30000" ) {\
set_Reading("WR_1_Speicher_1_ExternControl_smart_laden_before","aktiv");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_laden_before aktiv"};;\
} else {\
set_Reading("WR_1_Speicher_1_ExternControl_smart_laden_before","inaktiv");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_laden_before inaktiv"};;\
}\
\
fhem_set("WR_1_Speicher_1_ExternControl cmd_2");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_Laden startet"};;\
}\
\
set_Reading("ui_command_4","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
9_WB_1_Zaehler_Statistiken\
{if( !([$SELF:state] eq "off") and ## DOIF enabled\
[00:01]\
) {\
fhem("setreading WB_1 lp_1_kWhCounter_init_Day ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Day ".[WB_1:lp_2_kWhCounter]);;\
\
if ($mday eq 1)\
{\
fhem("setreading WB_1 lp_1_kWhCounter_init_Month ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Month ".[WB_1:lp_2_kWhCounter]);;\
\
if ($yday eq 0)\
{\
fhem("setreading WB_1 lp_1_kWhCounter_init_Year ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Year ".[WB_1:lp_2_kWhCounter]);;\
}\
}\
}\
}
attr Kia_eNiro_PV DbLogExclude .*
attr Kia_eNiro_PV disable 0
attr Kia_eNiro_PV group PV Eigenverbrauch-Steuerung
attr Kia_eNiro_PV icon car
attr Kia_eNiro_PV room Strom->Photovoltaik
attr Kia_eNiro_PV sortby 401
attr Kia_eNiro_PV uiTable {\
package ui_Table;;\
## $TR{0} = "style='color:yellow;;text-align:left;;font-weight:bold;;font-size:18px'";; ## Reihe 0 für Überschrift\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_batt {\
my($val)=@_;;\
my $ret="position:absolute;;left:".(90*$val/100)."px;;width:90px;;height:20px;;background:linear-gradient( to right,#F8F8E0 ".(90-(90*$val/100))."px,rgba(0,0,0,0) ".(90-(90*$val/100))."px);;";;\
return $ret;;\
}\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
sub FUNC_Status_Laden {\
my($car)=@_;;\
my $charge = (::ReadingsVal($car,"charging","false") eq "true");;\
my $athome = (::ReadingsVal($car,"atHomeStanding","false") eq "true");;\
my $chargeathome = ($charge && $athome);;\
my $connectedathome = ($athome && ::ReadingsVal($car,"connected","false") eq "true");;\
\
my $ret = ($chargeathome ? "lädt zu Hause" : ($connectedathome ? "angeschlossen zu Hause" : ($athome ? "zu Hause" : ($charge ? "Lädt auswärts" : "unterwegs"))));;\
return $ret;;\
}\
sub FUNC_tire {\
my($car)=@_;;\
my $ret = 'Reifendruck okay';;\
\
if (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampAll","1") != 0) {\
my $VL = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampFL","1") eq "0")?0:1;;\
my $HL = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampRL","1") eq "0")?0:1;;\
my $VR = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampFR","1") eq "0")?0:1;;\
my $HR = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampRR","1") eq "0")?0:1;;\
$ret = 'Reifen Störung ';;\
if ($VL == 1){$ret.=' /VL'};;\
if ($VR == 1){$ret.=' /VR'};;\
if ($HL == 1){$ret.=' /HL'};;\
if ($HR == 1){$ret.=' /HR'};;\
$ret = $ret.'';;\
}\
return $ret;;\
}\
sub FUNC_door {\
my($car)=@_;;\
my $ret = 'Türen okay ';;\
\
if (::ReadingsVal($car,"status_doorLock","false") ne "true") {\
my $VL = (::ReadingsVal($car,"status_doorOpen_frontLeft",1) == 0)?0:1;;\
my $HL = (::ReadingsVal($car,"status_doorOpen_backLeft",1) == 0)?0:1;;\
my $VR = (::ReadingsVal($car,"status_doorOpen_frontRight",1) == 0)?0:1;;\
my $HR = (::ReadingsVal($car,"status_doorOpen_backRight",1) == 0)?0:1;;\
$ret = 'Tür offen ';;\
if ($VL == 1){$ret.=' /VL'};;\
if ($VR == 1){$ret.=' /VR'};;\
if ($HL == 1){$ret.=' /HL'};;\
if ($HR == 1){$ret.=' /HR'};;\
$ret = $ret.'';;\
}\
if (::ReadingsVal($car,"status_trunkOpen","true") eq "true") {\
$ret.=' Kofferraum offen';;\
}\
if (::ReadingsVal($car,"status_hoodOpen","true") eq "true") {\
$ret.=' Motorhaube offen';;\
}\
return $ret;;\
}\
}\
\
"$SELF"|"Kommando ".::ReadingsTimestamp("Kia_connect","status_time","")."<dd>Auswahl / Kommunikation / Tacho / Info Status</dd>" | widget([$SELF:ui_command_1],"uzsuDropDown,---,Status_getAll,car_lock,car_unlock")|(([Kia_connect:req_active] eq "idle")?'idle' : ''.[Kia_connect:req_active].'') |::round([Kia_connect:odometer_value],0)." km"|FUNC_Status_Laden("Kia_connect")\
\
|"Accu<dd>Steuerung / Target Soc / Accu Status</dd>" |widget([$SELF:ui_command_3],"uzsuDropDown,---,setChargeTargetSoc,stopCharge,startCharge")|"Target SOC".widget([Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel_target],"selectnumbers,50,10,100,0,lin")." %"|""| FUNC_Status([Kia_connect:range],150,"red",[Kia_connect:range],"orange",[Kia_connect:range],250,"green",[Kia_connect:range])." km"."<div style='border-width:2px;;border-style:solid;;border-color:gray;;position:relative;;width:90px;;height:20px;;background:linear-gradient( to right, red 0px,yellow 30px,green 50px);;'>".STY(" ",FUNC_batt([Kia_connect:batSOC])).STY(::round([Kia_connect:batSOC],0)."%","font-size:16px;;position:absolute;;top:2px;;left:30px")."</div>"\
\
|"Komfort<dd>Timer / Klima / Reifen / Türen / Accu Status 12V</dd>" |widget([$SELF:ui_timer_mode],"uzsuDropDown,Aus,heizen,kuehlen").widget([$SELF:ui_timer_Start],"time")|\
((::ReadingsVal("Abfall_Abfuhr","Kiaheizen_days",0) != 0)?"Klimatisierung ".[Abfall_Abfuhr:Kiaheizen_connect_date]." ".[Abfall_Abfuhr:Kiaheizen_connect_time]:(([$SELF:ui_timer_mode] ne "Aus")?"Klimatisierung ".[$SELF:timer_04_c04]:""))|FUNC_tire("Kia_connect")." ".FUNC_door("Kia_connect")|\
"12 V<div style='border-width:2px;;border-style:solid;;border-color:gray;;position:relative;;width:90px;;height:20px;;background:linear-gradient( to right, red 0px,yellow 30px,green 50px);;'>".STY(" ",FUNC_batt([Kia_connect:bat12v])).STY(::round([Kia_connect:bat12v],0)."%","font-size:16px;;position:absolute;;top:2px;;left:30px")."</div>"\
\
|"<dd> Auswahl / Temperatur / Klima Status / Temperatur innen</dd>"| widget([$SELF:ui_command_2],"uzsuDropDown,---,stopClimate,startHeating,startCooling")|\
"Heat".widget([Kia_connect:status_airTemp_value_target_Winter],"selectnumbers,20,1,27,0,lin")."°C Cool".widget([Kia_connect:status_airTemp_value_target_Sommer],"selectnumbers,16,1,25,0,lin")."°C"|(([Kia_connect:status_airCtrlOn] eq "true")?'Klima läuft':'Klima aus')." ".(([Kia_connect:status_defrost] eq "true")?'Defrost ein':'Defrost aus') |"Aktuell ".[Kia_connect:status_airTemp_value]."°C"\
\
|"WallBox (WB_1_lp1)<dd>Lademodus / Info Status / Ladezeit / Leistung</dd>"|[WB_1:ChargeMode]." ".widget([$SELF:ui_command_4],"uzsuDropDown,---,SofortLaden,Min+PV,NurPV,Stop,Standby,Vorrang_EV,Vorrang_Bat,Hausspeicher_Sperren")|[WB_1:lp_1_PlugStat]." ".[WB_1:lp_1_ChargeStat]|[WB_1:lp_1_TimeRemaining]|[WB_1:lp_1_countPhasesInUse]."P ".[WB_1:lp_1_AConfigured]."A ".[WB_1:lp_1_W]." W"

setstate Kia_eNiro_PV 2022-01-12 13:24:24 ui_command_1 ---
setstate Kia_eNiro_PV 2022-01-10 09:18:53 ui_command_2 ---
setstate Kia_eNiro_PV 2021-11-09 07:56:54 ui_command_3 ---
setstate Kia_eNiro_PV 2022-01-12 13:02:41 ui_command_4 ---
setstate Kia_eNiro_PV 2022-01-12 13:02:41 ui_command_before_4 ---
setstate Kia_eNiro_PV 2021-11-29 09:56:58 ui_timer_Start 10:30
setstate Kia_eNiro_PV 2021-12-02 07:00:00 ui_timer_mode Aus
</syntaxhighlight>

=====Kostal Plenticore mit Speicher=====
Zu diesem Thema gibt es noch die Wiki Seite [[Kostal Plenticore Plus]], die alles rund um den Wechselrichter und vieles mehr erklärt.
Die hier beschriebene openWB und Kia connect Anbindung bedient sich der Hausspeichersteuerung, um diesen beim Laden der BEV zu sperren.
Im DOIF kann an den entsprechenden Stellen natürlich auch ein anders Kommando zum Sperren verwendet werden.

== Weiterführende Links ==
* [https://openwb.de openWB Website]
* [https://github.com/snaptec/openWB/wiki openWB Wiki bei GitHub]
* [https://www.openwb.de/forum/viewtopic.php?f=6&t=4159 openWB Forum (Diskussion zu diesem Artikel)]
* [https://openwb.de/forum/viewtopic.php?t=577 openWB Forum (Liste der MQTT-Topics)]

[[Kategorie:Elektromobilität]]
[[Kategorie:HOWTOS]]
[[Kategorie:Wallboxen]]

OpenWB

2025-01-12T15:55:54Z

Ch.eick: /* Node-red */

== Integration der openWB in FHEM - Ladeleistung anzeigen und Umschalten des Lademodus ==
Ausgangssituation ist ein funktionierendes FHEM, ohne weitere Vorbedingungen.<syntaxhighlight lang="perl">
defmod openwb MQTT <openWBip>:1883
attr openwb room Auto,MQTT

</syntaxhighlight>Dadurch wird der MQTT-Server der openWB angesprochen, FHEM ist der Client.

Ein Ladepunkt wird als MQTT_Device angelegt:<syntaxhighlight lang="perl">
defmod lp1 MQTT_DEVICE
attr lp1 IODev openwb
attr lp1 publishSet_chargeMode openWB/set/ChargeMode
attr lp1 room Auto,Dashboard,MQTT
attr lp1 stateFormat power
attr lp1 subscribeReading_chargeMode openWB/global/ChargeMode
attr lp1 subscribeReading_plugStat openWB/lp/1/boolPlugStat
attr lp1 subscribeReading_power openWB/lp/1/W
</syntaxhighlight>Die Umsetzung basiert auf openWB 1.9.x, der Lademodus "ChargeMode" gilt hier noch global für alle Ladepunkte.

Beispielhaft die Definition des zweiten Ladepunktes, eine zweite openWB, die als "nur Ladepunkt" mit der angesprochenen openWB verbunden ist.

Eine openWB kann derzeit 8 Ladepunkte verwalten, die Nummern müssen entsprechend inkrementiert werden.<syntaxhighlight lang="perl">
defmod lp2 MQTT_DEVICE
attr lp2 IODev openwb
attr lp2 publishSet_chargeMode openWB/set/ChargeMode
attr lp2 room Auto,Dashboard,MQTT
attr lp2 stateFormat power
attr lp2 subscribeReading_chargeMode openWB/global/ChargeMode
attr lp2 subscribeReading_plugStat openWB/lp/2/boolPlugStat
attr lp2 subscribeReading_power openWB/lp/2/W
</syntaxhighlight>Die MQTT-Topics zum Lesen und Schreiben von Werten sind ganz unten auf dieser Wiki-Seite zu finden.

Die Einbindung in die TabletUI sieht bei mir so aus:
[[Datei:Ladepunkte in TabletUI.png|alternativtext=Darstellung der openWB Ladepunkte in der TabletUI|mini|488x488px|Beispielhafte Darstellung in der TabletUI]]
[[Datei:Auswahl des Lademodus.png|alternativtext=Darstellung der openWB Ladepunkte in der TabletUI - Auswahl des Lademodus|mini|486x486px|Auswahl des Lademodus per CircleMenu]]
<syntaxhighlight lang="html">
<div class="cell-60 left-space right-space">
<div data-type="symbol" data-icon="fa-car" class="tall compressed" data-color="lightgray">
<div data-type="circlemenu" data-direction="full" class="mini" style="top: -0.5em;">
<ul class="mini">
<li><div data-type="push" data-device="lp1" data-get="chargeMode" data-states='[0,1,2,3,4]' data-colors='["lightgreen","greenyellow","yellow","grey","black"]' data-icons='["fa-bolt","fa-plus-circle","fa-sun-o","fa-pause-circle-o","fa-stop-circle-o"]' data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="0" data-get-on="0" data-icon="fa-bolt" data-color="lightgreen" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="1" data-get-on="1" data-icon="fa-plus-circle" data-color="greenyellow" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="2" data-get-on="2" data-icon="fa-sun-o" data-color="yellow" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="3" data-get-on="3" data-icon="fa-pause-circle-o" data-color="grey" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="4" data-get-on="4" data-icon="fa-stop-circle-o" data-color="black" data-background-icon=""></div></li>
</ul>
</div>
<div style="font-size: 30% !important;" class="mini " data-pre-text="" data-type="label" data-device="lp1" data-get="power" data-unit="" data-factor="1" data-fix="0"></div>
<div data-type="symbol" data-device="lp1" data-get="plugStat" data-states='[0,1]' data-colors='["white","black"]' data-icons='["","fa-plug"]' data-background-icon="" class="mini" style="font-size: 30% !important; top:1em;"></div></li>
</div>
</div>

</syntaxhighlight>

==Integration OpenWB in FHEM - Übertragung von EVU, PV und Batteriewerten an openWB==
Ausgangssituation ist ein funktionierendes FHEM-System, bei dem bereits der digitale Stromzähler ("Moderne Meßeinrichtung") über das Modul 47_OBIS und der PV-Wechselrichter über ein entsprechendes Modul, z.B. ModbusAttr integriert sind. Als OpenWB-System wurde hier eine reale OpenWB-Wallbox angebunden.

=== Datenquellen ===
Die OpenWB erwartet 1-3 Typen von Datenquellen in dieser Konstellation:
* Die ''EVU-''Schnittstelle, mit der als wesentlicher Steuerparameter der Ladeleistung die Leistungsmessung am Hausübergang herangezogen wird, und daneben die Zählerwerte für Netzbezug und Einspeisung zur Visualisierung übertragen werden sollten. Nur, falls phasenbezogenes Lastmanagement erforderlich sein sollte, sind auch die einzelnen Phasenleistungswerte vom Stromzähler nötig (was nicht jede Moderne Meßeinrichtung auf der OBIS-Schnittstelle bereitstellt)
* Die ''PV-''Schnittstelle, die ebenfalls primär visualisierende Bedeutung hat.
* Die ''Batteriespeicher-''Schnittstelle
OpenWB kann auch z.B. rein mit einer PV-Schnittstelle betrieben werden, in diesem Fall wird ein konstanter Leistungswert für den Hausbezug angenommen.

=== Kommunikationsprotokoll ===
Zur Kommunikation mit FHEM bieten sich 2 Methoden an:
* '''HTTP'''-Abfrage durch OpenWB bei FHEM durch das generische HTTP-Modul von OpenWB Diese Methode beschreibe ich nicht, weil sie mehr Overhead erzeugt und seitens FHEM die Einrichtung eines CSRF-Token-freien Web-Kanals erfordert
* '''MQTT'''-Push durch FHEM zur OpenWB Diese Methode erscheint mir vorteilhafter, weil auf einer stehenden TCP-Verbindung lediglich Meßwerte gepusht werden.

=== Implementierung ===

==== Vorbereitung ====
In der OpenWB-Web-UI unter Modulkonfiguration die entsprechenden Module (EVU, PV, Batterie) auf MQTT stellen. Hinweis: Nicht alle dabei erscheinenden MQTT-Topics müssen mit Werten beliefert werden! Sowohl bei der EVU-Schnittstelle wie bei PV reichen Momentanleistung und Zählerstände für eine zufriedenstellende Anbindung!

==== Definition der OpenWB als MQTT-Target ====
defmod openwb_mqtt MQTT2_CLIENT <ip-der-openwb>:1883
attr openwb_mqtt autocreate simple
attr openwb_mqtt subscriptions openWB/lp/1/#

==== Übertragung der EVU-Meßwerte ====
In diesem Beispiel heißt das die Stromzählerdaten liefernde Device am OBIS-Modul "MT175". Die Zahlen werden per Notify von diesem Device auf MQTT kopiert:
defmod openwb_evu_cons notify MT175:total_consumption:.* { fhem("set openwb_mqtt publish openWB/set/evu/WhImported " . $EVTPART1); }
defmod openwb_evu_feed notify MT175:total_feed:.* { fhem("set openwb_mqtt publish openWB/set/evu/WhExported " . $EVTPART1); }
defmod openwb_evu_w notify MT175:power:.* { fhem("set openwb_mqtt publish openWB/set/evu/W " . int($EVTPART1)); }

==== Übertragung der PV-Meßwerte ====
Sofern die Daten für Momentanleistung und Zählerstand direkt in einem Device vorliegen, können analoge Notifys für dieses Device implementiert werden. Die Zielwerte lauten:
* Für den Momentan-Leistungswert <code>openWB/set/pv/1/W</code>
* Für den Zählerstand <code>openWB/set/pv/1/WhCounter</code>
Dabei muss beachtet werden, dass - wie bei der EVU-Schnittstelle - nur Integerwerte für die Momentanleistung übertragen werden dürfen.

==== Anbindung an Alexa ====
Der generische Smarthome-Skill "FHEMConnector" erlaubt nur die leider immer noch sehr limitierte Syntax von Amazon Alexa. Im Folgenden werden die Definitionen für die Befehle:
* ''"Alexa, schalte Überschussladen ein"''
* ''"Alexa, schalte Überschussladen aus"''
* ''"Alexa, schalte Überschussladen auf 6 (Prozent)"''
dargestellt. "Überschussladen auf 6" bedeutet dabei real den "Min+PV", also Überschussladen mit Minimalleistung von 6 Ampere. Je nach Tagesform von Amazon ist dabei das Sprechen von "Prozent" nötig, auch wenn dies natürlich sachlich falsch ist.
define openwb_ueberschuss dummy
attr openwb_ueberschuss alexaName Überschussladen
attr openwb_ueberschuss genericDeviceType light
attr openwb_ueberschuss readingList pct
attr openwb_ueberschuss setList on off pct
define openwb_ueberschuss_on notify openwb_ueberschuss:on set openwb_mqtt publish openWB/set/ChargeMode 2
define openwb_ueberschuss_off notify openwb_ueberschuss:off set openwb_mqtt publish openWB/set/ChargeMode 3
define openwb_ueberschuss_pct notify openwb_ueberschuss:pct:.* set openwb_mqtt publish openWB/config/set/pv/minCurrentMinPv $EVTPART1 ;; set openwb_mqtt publish openWB/set/ChargeMode 1

==Anwendungs Beispiele==
===Komplexe Anbindung===
[[Bild:Kia.PNG|mini|700px|rechts|WallBox mit Kia Fahrzeug]]
Hier mal ein Beispiel mit weiteren Schnittstellen in der Haussteuerung. Im Hintergrund arbeitet ein Wechselrichter Schwarm mit einem Hausspeicher, der beim BEV Laden gesperrt wird. Die openWB kommuniziert direkt mit den zwei Kostal Wechselrichtern, dem KSEM und dem am Master angeschlossenen Speicher. Das BEV ist über Kia Connect angebunden.
[[Bild:WB_1.PNG|mini|700px|rechts|openWB mit Statistiken]]
[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss, inklusive Wechselrichter, raus kommen. Die openWBs sind unten links.]]
====Verwendete Schnittstellen / Devices====
=====openWB MQTT=====
Wie oben beschrieben mit folgender MQTT definition. Im Bild ist das DOIF dargestellt und das MQTT Device als kurze Darstellung unterhalb der Tabelle. Das MQTT wird nur zur Kopplung verwendet, hat jedoch jetzt auch ein stateFormat inklusieve Statistiken erhalten.

RAW des MQTT Device
<syntaxhighlight lang="Perl">
defmod WB_1 MQTT2_DEVICE WB_1_MQTT2
attr WB_1 DbLogExclude .*
attr WB_1 DbLogInclude lp_1_.*,.*AllChargePoints.*,ChargeMode
attr WB_1 IODev WB_1_MQTT2
attr WB_1 alias WB_1
attr WB_1 autocreate 0
attr WB_1 comment Die openWB besteht aus zwei Ladepunkten.
attr WB_1 devicetopic openWB
attr WB_1 disable 0
attr WB_1 event-on-change-reading lp_1_.*,.*AllChargePoints.*,ChargeMode
attr WB_1 group PV Eigenverbrauch
attr WB_1 icon fuel
attr WB_1 readingList $DEVICETOPIC/global/WHouseConsumption:.* WHouseConsumption\
$DEVICETOPIC/global/WAllChargePoints:.* WAllChargePoints\
$DEVICETOPIC/global/ChargeMode:.* {my %h=(0=>'SofortLaden',1=>'MinPV',2=>'NurPV',3=>'Stop',4=>'Standby');; return {ChargeMode=>$h{$EVENT}}}\
\
$DEVICETOPIC/global/awattar/boolAwattarEnabled:.* boolAwattarEnabled\
$DEVICETOPIC/global/awattar/ActualPriceForCharging:.* ActualPriceForCharging\
$DEVICETOPIC/global/awattar/MaxPriceForCharging:.* MaxPriceForCharging\
$DEVICETOPIC/global/boolRse:.* boolRse\
$DEVICETOPIC/global/DailyYieldAllChargePointsKwh:.* DailyYieldAllChargePointsKwh\
$DEVICETOPIC/global/rfidConfigured:.* rfidConfigured\
$DEVICETOPIC/global/kWhCounterAllChargePoints:.* kWhCounterAllChargePoints\
$DEVICETOPIC/global/strLastmanagementActive:.* strLastmanagementActive\
$DEVICETOPIC/global/ETProvider/modulePath:.* modulePath\
$DEVICETOPIC/global/cpuTemp:.* cpuTemp\
\
$DEVICETOPIC/system/Uptime:.* Uptime\
$DEVICETOPIC/system/Date:.* Date\
$DEVICETOPIC/system/Timestamp:.* Timestamp\
$DEVICETOPIC/system/Version:.* Version\
$DEVICETOPIC/system/IpAddress:.* IpAddress\
$DEVICETOPIC/system/lastRfId:.* lastRfId\
$DEVICETOPIC/system/updateInProgress:.* updateInProgress\
$DEVICETOPIC/system/ConfiguredChargePoints:.* ConfiguredChargePoints\
$DEVICETOPIC/system/lastlivevalues:.* lastlivevalues\
$DEVICETOPIC/system/randomSleep:.* randomSleep\
$DEVICETOPIC/system/wizzardDone:.* wizzardDone\
$DEVICETOPIC/system/priceForKWh:.* priceForKWh\
$DEVICETOPIC/system/reloadDisplay:.* reloadDisplay\
\
$DEVICETOPIC/evu/ASchieflast:.* ASchieflast\
\
$DEVICETOPIC/lp/1/P%Soc:.* lp_1_Pct_Soc\
$DEVICETOPIC/lp/1/%Soc:.* lp_1_current_Soc\
$DEVICETOPIC/lp/1/\x25Soc:.* lp_1__Soc\
\
$DEVICETOPIC/lp/1/countPhasesInUse:.* lp_1_countPhasesInUse\
$DEVICETOPIC/lp/1/ChargePointEnabled:.* lp_1_ChargePointEnabled\
$DEVICETOPIC/lp/1/ChargeStatus:.* lp_1_ChargeStatus\
\
$DEVICETOPIC/lp/1/kWhDailyCharged:.* lp_1_kWhDailyCharged\
$DEVICETOPIC/lp/1/kWhCounter:.* lp_1_kWhCounter\
$DEVICETOPIC/lp/1/kWhActualCharged:.* lp_1_kWhActualCharged\
$DEVICETOPIC/lp/1/kWhChargedSincePlugged:.* lp_1_kWhChargedSincePlugged\
$DEVICETOPIC/lp/1/energyConsumptionPer100km:.* lp_1_energyConsumptionPer100km\
$DEVICETOPIC/lp/1/kmCharged:.* lp_1_kmCharged\
\
$DEVICETOPIC/lp/1/strChargePointName:.* lp_1_strChargePointName\
$DEVICETOPIC/lp/1/TimeRemaining:.* lp_1_TimeRemaining\
\
$DEVICETOPIC/lp/1/PfPhase2:.* lp_1_PfPhase2\
$DEVICETOPIC/lp/1/PfPhase3:.* lp_1_PfPhase3\
$DEVICETOPIC/lp/1/PfPhase1:.* lp_1_PfPhase1\
$DEVICETOPIC/lp/1/W:.* lp_1_W\
\
$DEVICETOPIC/lp/1/boolPlugStat:.* {my %h=(0=>'no Plug',1=>'Plugged in');; return {lp_1_PlugStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/1/boolChargeStat:.* {my %h=(0=>'not loading',1=>'loading');; return {lp_1_ChargeStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/1/AConfigured:.* lp_1_AConfigured\
\
$DEVICETOPIC/lp/1/boolChargePointConfigured:.* lp_1_boolChargePointConfigured\
$DEVICETOPIC/lp/1/boolSocConfigured:.* lp_1_boolSocConfigured\
$DEVICETOPIC/lp/1/boolDirectModeChargekWh:.* lp_1_boolDirectModeChargekWh\
$DEVICETOPIC/lp/1/boolDirectChargeModeSoc:.* lp_1_boolDirectChargeModeSoc\
$DEVICETOPIC/lp/1/boolFinishAtTimeChargeActive:.* lp_1_boolFinishAtTimeChargeActive\
$DEVICETOPIC/lp/1/boolChargeAtNight:.* lp_1_boolChargeAtNight\
$DEVICETOPIC/lp/1/boolSocManual:.* lp_1_boolSocManual\
\
$DEVICETOPIC/lp/1/AutolockStatus:.* lp_1_AutolockStatus\
$DEVICETOPIC/lp/1/AutolockConfigured:.* lp_1_AutolockConfigured\
\
$DEVICETOPIC/lp/1/lastRfId:.* lp_1_lastRfId\
$DEVICETOPIC/lp/1/pluggedladungakt:.* lp_1_pluggedladungakt\
$DEVICETOPIC/lp/1/plugStartkWh:.* lp_1_plugStartkWh\
$DEVICETOPIC/lp/1/MeterSerialNumber:.* lp_1_MeterSerialNumber\
\
\
$DEVICETOPIC/lp/2/P%Soc:.* lp_2_Pct_Soc\
$DEVICETOPIC/lp/2/%Soc:.* lp_2_current_Soc\
$DEVICETOPIC/lp/2/\x25Soc:.* lp_2__Soc\
\
$DEVICETOPIC/lp/2/countPhasesInUse:.* lp_2_countPhasesInUse\
$DEVICETOPIC/lp/2/ChargePointEnabled:.* lp_2_ChargePointEnabled\
$DEVICETOPIC/lp/2/ChargeStatus:.* lp_2_ChargeStatus\
\
$DEVICETOPIC/lp/2/kWhDailyCharged:.* lp_2_kWhDailyCharged\
$DEVICETOPIC/lp/2/kWhCounter:.* lp_2_kWhCounter\
$DEVICETOPIC/lp/2/kWhActualCharged:.* lp_2_kWhActualCharged\
$DEVICETOPIC/lp/2/kWhChargedSincePlugged:.* lp_2_kWhChargedSincePlugged\
$DEVICETOPIC/lp/2/energyConsumptionPer100km:.* lp_2_energyConsumptionPer100km\
$DEVICETOPIC/lp/2/kmCharged:.* lp_2_kmCharged\
\
$DEVICETOPIC/lp/2/strChargePointName:.* lp_2_strChargePointName\
$DEVICETOPIC/lp/2/TimeRemaining:.* lp_2_TimeRemaining\
\
$DEVICETOPIC/lp/2/W:.* lp_2_W\
\
$DEVICETOPIC/lp/2/boolPlugStat:.* {my %h=(0=>'no Plug',1=>'Plugged in');; return {lp_2_PlugStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/2/boolChargeStat:.* {my %h=(0=>'not loading',1=>'loading');; return {lp_2_ChargeStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/2/AConfigured:.* lp_2_AConfigured\
\
$DEVICETOPIC/lp/2/boolChargePointConfigured:.* lp_2_boolChargePointConfigured\
$DEVICETOPIC/lp/2/boolSocConfigured:.* lp_2_boolSocConfigured\
$DEVICETOPIC/lp/2/boolDirectModeChargekWh:.* lp_2_boolDirectModeChargekWh\
$DEVICETOPIC/lp/2/boolDirectChargeModeSoc:.* lp_2_boolDirectChargeModeSoc\
$DEVICETOPIC/lp/2/boolFinishAtTimeChargeActive:.* lp_2_boolFinishAtTimeChargeActive\
$DEVICETOPIC/lp/2/boolChargeAtNight:.* lp_2_boolChargeAtNight\
$DEVICETOPIC/lp/2/boolSocManual:.* lp_2_boolSocManual\
\
$DEVICETOPIC/lp/2/AutolockStatus:.* lp_2_AutolockStatus\
$DEVICETOPIC/lp/2/AutolockConfigured:.* lp_2_AutolockConfigured\
\
$DEVICETOPIC/lp/2/lastRfId:.* lp_2_lastRfId\
$DEVICETOPIC/lp/2/pluggedladungakt:.* lp_2_pluggedladungakt\
$DEVICETOPIC/lp/2/plugStartkWh:.* lp_2_plugStartkWh\
$DEVICETOPIC/lp/2/MeterSerialNumber:.* lp_2_MeterSerialNumber\
\
\
$DEVICETOPIC/boolChargeAtNight_direct:.* boolChargeAtNight_direct\
$DEVICETOPIC/boolChargeAtNight_nurpv:.* boolChargeAtNight_nurpv\
$DEVICETOPIC/boolChargeAtNight_minpv:.* boolChargeAtNight_minpv\
$DEVICETOPIC/boolDisplayHouseConsumption:.* boolDisplayHouseConsumption\
$DEVICETOPIC/boolDisplayDailyCharged:.* boolDisplayDailyCharged\
$DEVICETOPIC/boolEvuSmoothedActive:.* boolEvuSmoothedActive\
$DEVICETOPIC/pv/bool70PVDynActive:.* bool70PVDynActive\
$DEVICETOPIC/pv/W70PVDyn:.* W70PVDyn\
$DEVICETOPIC/pv/bool70PVDynStatus:.* bool70PVDynStatus\
$DEVICETOPIC/pv/CounterTillStartPvCharging:.* CounterTillStartPvCharging\
$DEVICETOPIC/pv/W:.* W\
$DEVICETOPIC/config/get/pv/nurpv70dynact:.* nurpv70dynact\
$DEVICETOPIC/config/get/pv/nurpv70dynw:.* nurpv70dynw\
$DEVICETOPIC/config/get/pv/priorityModeEVBattery:.* priorityModeEVBattery\
$DEVICETOPIC/config/get/pv/lp/1/minSocAlwaysToChargeTo:.* lp_1_minSocAlwaysToChargeTo\
$DEVICETOPIC/config/get/pv/lp/1/maxSoc:.* lp_1_maxSoc\
$DEVICETOPIC/config/get/pv/lp/1/minSocAlwaysToChargeToCurrent:.* lp_1_minSocAlwaysToChargeToCurrent\
$DEVICETOPIC/config/get/pv/lp/1/maxSocToChargeTo:.* lp_1_maxSocToChargeTo\
$DEVICETOPIC/config/get/pv/lp/1/minCurrent:.* lp_1_minCurrent\
$DEVICETOPIC/config/get/pv/lp/1/socLimitation:.* lp_1_socLimitation\
$DEVICETOPIC/config/get/pv/lp/2/minCurrent:.* lp_2_minCurrent\
$DEVICETOPIC/config/get/pv/lp/2/maxSoc:.* lp_2_maxSoc\
$DEVICETOPIC/config/get/pv/lp/2/socLimitation:.* lp_2_socLimitation\
$DEVICETOPIC/config/get/pv/socStopChargeAtMinPv:.* socStopChargeAtMinPv\
$DEVICETOPIC/config/get/pv/regulationPoint:.* regulationPoint\
$DEVICETOPIC/config/get/pv/minBatteryDischargeSocAtBattPriority:.* minBatteryDischargeSocAtBattPriority\
$DEVICETOPIC/config/get/pv/minBatteryChargePowerAtEvPriority:.* minBatteryChargePowerAtEvPriority\
$DEVICETOPIC/config/get/pv/minFeedinPowerBeforeStart:.* minFeedinPowerBeforeStart\
$DEVICETOPIC/config/get/pv/boolAdaptiveCharging:.* boolAdaptiveCharging\
$DEVICETOPIC/config/get/pv/adaptiveChargingFactor:.* adaptiveChargingFactor\
$DEVICETOPIC/config/get/pv/batteryDischargePowerAtBattPriority:.* batteryDischargePowerAtBattPriority\
$DEVICETOPIC/config/get/pv/boolShowPriorityIconInTheme:.* boolShowPriorityIconInTheme\
$DEVICETOPIC/config/get/pv/maxPowerConsumptionBeforeStop:.* maxPowerConsumptionBeforeStop\
$DEVICETOPIC/config/get/pv/stopDelay:.* stopDelay\
$DEVICETOPIC/config/get/pv/chargeSubmode:.* chargeSubmode\
$DEVICETOPIC/config/get/pv/minCurrentMinPv:.* minCurrentMinPv\
$DEVICETOPIC/config/get/pv/socStartChargeAtMinPv:.* socStartChargeAtMinPv\
$DEVICETOPIC/config/get/pv/startDelay:.* startDelay\
$DEVICETOPIC/config/get/sofort/lp/2/energyToCharge:.* lp_2_energyToCharge\
$DEVICETOPIC/config/get/sofort/lp/2/chargeLimitation:.* lp_2_chargeLimitation\
$DEVICETOPIC/config/get/sofort/lp/2/socToChargeTo:.* lp_2_socToChargeTo\
$DEVICETOPIC/config/get/sofort/lp/2/current:.* lp_2_current\
\
$DEVICETOPIC/config/get/sofort/lp/1/socToChargeTo:.* lp_1_socToChargeTo\
\
$DEVICETOPIC/config/get/sofort/lp/1/energyToCharge:.* lp_1_energyToCharge\
$DEVICETOPIC/config/get/sofort/lp/1/chargeLimitation:.* lp_1_chargeLimitation\
$DEVICETOPIC/config/get/sofort/lp/1/current:.* lp_1_current\
$DEVICETOPIC/config/get/global/minEVSECurrentAllowed:.* minEVSECurrentAllowed\
$DEVICETOPIC/config/get/global/maxEVSECurrentAllowed:.* maxEVSECurrentAllowed\
$DEVICETOPIC/config/get/global/dataProtectionAcknoledged:.* dataProtectionAcknoledged\
$DEVICETOPIC/config/get/global/slaveMode:.* slaveMode\
$DEVICETOPIC/config/get/u1p3p/standbyPhases:.* standbyPhases\
$DEVICETOPIC/config/get/u1p3p/sofortPhases:.* sofortPhases\
$DEVICETOPIC/config/get/u1p3p/nachtPhases:.* nachtPhases\
$DEVICETOPIC/config/get/u1p3p/minundpvPhases:.* minundpvPhases\
$DEVICETOPIC/config/get/u1p3p/nurpvPhases:.* nurpvPhases\
$DEVICETOPIC/config/get/u1p3p/isConfigured:.* isConfigured\
$DEVICETOPIC/boolChargeAtNight_standby:.* boolChargeAtNight_standby\
$DEVICETOPIC/set/system/reloadDisplay:.* reloadDisplay\
$DEVICETOPIC/set/system/topicSender:.* topicSender\
$DEVICETOPIC/set/lp/2/faultState:.* lp_2_faultState\
$DEVICETOPIC/set/lp/2/faultStr:.* lp_2_faultStr\
$DEVICETOPIC/set/lp/2/ChargePointEnabled:.* lp_2_ChargePointEnabled
attr WB_1 room MQTT2_DEVICE,Strom->Photovoltaik
attr WB_1 setList Lademodus:SofortLaden,Min+PV,NurPV,Stop,Standby { my %h=(SofortLaden=>'0','Min+PV'=>'1',NurPV=>'2',Stop=>'3',Standby=>'4');;qq($DEVICETOPIC/set/ChargeMode $h{$EVTPART1}) }\
DirectChargeSubMode:Aus,kWh_Laden,SoC_Laden { my %h=(Aus=>'0',kWh_Laden=>'1',SoC_Laden=>'2');;qq($DEVICETOPIC/set/lp1/DirectChargeSubMode $h{$EVTPART1}) }\
lp_1_socToChargeTo:50,60,70,80,90,100 { qq($DEVICETOPIC/config/set/sofort/lp/1/socToChargeTo $EVTPART1) }
attr WB_1 sortby 311
attr WB_1 stateFormat {\
my $YearBefore='LogDBRep_Statistic_previous_Year';;\
my $DUMMY = "";;\
my $date = POSIX::strftime("%Y-%m-%d",localtime(time_str2num(ReadingsTimestamp($name, "lastlivevalues",0))));;\
\
my $ChargeMode = ReadingsVal($name,"ChargeMode","n/a");;\
$ChargeMode = ($ChargeMode eq "SofortLaden")? "SofortLaden" : ($ChargeMode eq "MinPV")? "Min+PV" : ($ChargeMode eq "NurPV")? "NurPV" : $ChargeMode;;\
\
my $lp_1_Name = ReadingsVal($name,"lp_1_strChargePointName","n/a");;\
my $lp_1_Power = ReadingsVal($name,"lp_1_W",0)." W";;\
my $lp_1_Power_1 = ReadingsVal($name,"lp_1_countPhasesInUse",0)."P ".ReadingsVal($name,"lp_1_AConfigured",0)."A";;\
my $lp_1_Status_1 = ReadingsVal($name,"lp_1_PlugStat","n/a")." ".ReadingsVal($name,"lp_1_ChargeStat","n/a");;\
my $lp_1_Status_2 = ReadingsVal($name,"lp_1_TimeRemaining","n/a");;\
\
my $lp_1_Power_d = ReadingsVal($name,"lp_1_kWhDailyCharged",0)." kWh";;\
my $lp_1_Power_m = round(ReadingsVal($name,"lp_1_kWhCounter_Month",0),0)." kWh";;\
my $lp_1_Power_j = sprintf("%04d / %04d",ReadingsVal($name,"lp_1_kWhCounter_Year",0),ReadingsVal($YearBefore,"lp_1_kWhCounter_Year",0));;\
my $lp_1_Power_t = round(ReadingsVal($name,"lp_1_kWhCounter",0),0)." kWh";;\
\
my $lp_2_Name = ReadingsVal($name,"lp_2_strChargePointName","n/a");;\
my $lp_2_Power = ReadingsVal($name,"lp_2_W",0)." W";;\
my $lp_2_Power_1 = ReadingsVal($name,"lp_2_countPhasesInUse",0)."P ".ReadingsVal($name,"lp_2_AConfigured",0)."A";;\
my $lp_2_Status_1 = ReadingsVal($name,"lp_2_PlugStat","n/a")." ".ReadingsVal($name,"lp_2_ChargeStat","n/a");;\
my $lp_2_Status_2 = " ".ReadingsVal($name,"lp_2_TimeRemaining","n/a");;\
\
my $lp_2_Power_d = ReadingsVal($name,"lp_2_kWhDailyCharged",0)." kWh";;\
my $lp_2_Power_m = round(ReadingsVal($name,"lp_2_kWhCounter_Month",0),0)." kWh";;\
my $lp_2_Power_j = sprintf("%04d / %04d",ReadingsVal($name,"lp_2_kWhCounter_Year",0),ReadingsVal($YearBefore,"lp_2_kWhCounter_Year",0));;\
my $lp_2_Power_t = round(ReadingsVal($name,"lp_2_kWhCounter",0),0)." kWh";;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 52%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
</colgroup>\
<tr><td style='padding-right:5px;;padding-left:5px;;font-weight:bold'>Wallbox</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>$ChargeMode</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Status</td><td style='padding-right:5px;;padding-left:5px;;text-align:center;;font-weight:bold'>Restladezeit</td><td style='padding-right:5px;;padding-left:5px;;text-align:center;;font-weight:bold'>Leistung</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_1_Name."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$DUMMY."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Status_1."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Status_2." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_1." ".$lp_1_Power."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_2_Name."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$DUMMY."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Status_1."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Status_2." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_1." ".$lp_2_Power."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;font-weight:bold'>Statistik vom $date</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>aktuell</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Heute</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Monat</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Jahr/Vorjahr</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_1_Name."<td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_d."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_m." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_j."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_2_Name."<td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_d."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_m." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_j."</td></tr>\
</table>\
</html>"\
}
attr WB_1 userReadings lp_1_kWhCounter_Month:lp_1_kWhCounter.* { round(ReadingsVal("$NAME","lp_1_kWhCounter",0) - ReadingsVal("$NAME","lp_1_kWhCounter_init_Month",0),0) },\
lp_1_kWhCounter_Year:lp_1_kWhCounter.* { round(ReadingsVal("$NAME","lp_1_kWhCounter",0) - ReadingsVal("$NAME","lp_1_kWhCounter_init_Year",0),0) },\
\
lp_2_kWhCounter_Month:lp_2_kWhCounter.* { round(ReadingsVal("$NAME","lp_2_kWhCounter",0) - ReadingsVal("$NAME","lp_2_kWhCounter_init_Month",0),0) },\
lp_2_kWhCounter_Year:lp_2_kWhCounter.* { round(ReadingsVal("$NAME","lp_2_kWhCounter",0) - ReadingsVal("$NAME","lp_2_kWhCounter_init_Year",0),0) }
</syntaxhighlight>

=====Kia connect MQTT=====
Das Kia_connect Device empfängt und sendet die MQTT Nachrichten zum Node-red Flow für das Kia BEV.

RAW des Kia connect
<syntaxhighlight lang="Perl">
defmod Kia_connect MQTT2_DEVICE
attr Kia_connect DbLogExclude .*
attr Kia_connect DbLogInclude .*
attr Kia_connect IODev MQTT2_FHEM_Server
attr Kia_connect alias Kia_connect
attr Kia_connect autocreate 1
attr Kia_connect devicetopic bluelinky
attr Kia_connect group PV Eigenverbrauch-Steuerung
attr Kia_connect icon car
attr Kia_connect readingList $DEVICETOPIC/status:.* { json2nameValue($EVENT) }\
$DEVICETOPIC/location.* { json2nameValue($EVENT) }\
$DEVICETOPIC/odometer:.* { json2nameValue($EVENT) }\
$DEVICETOPIC/req_received:.* req_received\
$DEVICETOPIC/req_active:.* req_active
attr Kia_connect room MQTT2_DEVICE,Strom->Photovoltaik
attr Kia_connect setList getOdometer req/$DEVICETOPIC/get_odometer get_odometer\
getStatus req/$DEVICETOPIC/get_status get_status\
getLocation req/$DEVICETOPIC/get_location get_location\
getTripinfo req/$DEVICETOPIC/get_tripinfo\
getAll req/$DEVICETOPIC/get_all get_all\
setChargeTargetSoc req/$DEVICETOPIC/set_chargetargets\
startCharge req/$DEVICETOPIC/start_charging start_charging\
stopCharge req/$DEVICETOPIC/stop_charging stop_charging\
stopClimate req/$DEVICETOPIC/stop_climate stop_climate\
startClimate req/$DEVICETOPIC/start_climate
attr Kia_connect sortby 402
attr Kia_connect stateFormat req_active
attr Kia_connect userReadings atHomeStanding:location.* { ((abs(AttrVal("global","latitude",49.85) - ReadingsVal($NAME,"location_coord_lat",0)) <= 0.001) && (abs(AttrVal("global","longitude",8.49) - ReadingsVal($NAME,"location_coord_lon",0)) <= 0.001) && (ReadingsVal($NAME,"location_speed_value",1) == 0)) ? 'true' : 'false';;;; },\
batSOC:status.* { ReadingsVal($NAME,"status_evStatus_batteryStatus",0);;;;},\
connected:status.* { (ReadingsVal($NAME,"status_evStatus_batteryPlugin",0) != 0) ? 'true' : 'false';;;;},\
charging:status.* { ReadingsVal($NAME,"status_evStatus_batteryCharge",'false');;;;},\
targetSOC:status.* { ReadingsVal($NAME,"status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel",0);;;;},\
time2targetSOC:status.* { my $t = ReadingsVal($NAME,"status_evStatus_remainTime2_atc_value",1);;;; sprintf("%02d:%02d", $t/60%60, $t%60);;},\
range:status.* { ReadingsVal($NAME,"status_evStatus_drvDistance_1_rangeByFuel_totalAvailableRange_value",0);;;;},\
bat12v:status.* { ReadingsVal($NAME,"status_battery_batSoc",0);;;;}
</syntaxhighlight>

=====Node-red=====
[[Bild:Kia Flow.PNG|mini|900px|rechts|Node-red Kia Flow]]
Node-red habe ich einfach in einem Docker Container runter geladen und gestartet. Über Port 1880 kommt man direkt in die GUI und kann den ersten Flow laden.

docker-compose .yml Eintrag
<syntaxhighlight lang="Perl">
node-red:
image: nodered/node-red:latest
restart: always
environment:
- TZ=Europe/Berlin
ports:
- 1880:1880
volumes:
- ./node-red/data:/data
</syntaxhighlight>

Danach fehlt im Container noch folgende Erweiterung für den Node-red Flow
<syntaxhighlight lang="Perl">
npm install node-red-contrib-bluelinky
</syntaxhighlight>

Im MQTT muss dann noch der Benutzer und das Passwort abgelegt werden. Ansonst kommt nämlich im FHEM nichts a Dies muss direkt in node-red gemacht werden.

=====Kia Connect=====
<pre>
Kia connect ist eine API für Kia und Hyundai E-Autos mit der man Daten vom Auto abfragen kann und auch einige Steuerungen möglich sind.
Mit Node-red und BlueLinky wird die Schnittstelle bedient.
Der Flow ist nicht ursprünglich von mir, wurde jedoch noch erweitert.
Vor dem Laden des Flows sind noch die persönlichen Verbindungsdaten im JSON einzutragen.

Nach dem Laden ist ein Test mit den Inject Symbolen und der Debug Funktionalität möglich und auch sinnvoll.
Unterhalb der MQTT - und BlueLinky Symbole sollte "Verbunden" oder "Ready" erscheinen.
</pre>
'''Wichtig beim Kia ist, dass für das Laden über die openWB als SOC Ziel 80% im standard Modus konfiguriert wird.''' Ansonsten wundert man sich warum das Laden einfach nicht starten möchte. Im Default ist dort bei mir nur 50% eingetragen gewesen :-). Mit jetzt 100% kann die openWB auch selber einen Ziel SOC bestimmen, ansonsten hört das BEV einfach selber auf zu laden.

Weiterhin sollte man darauf achten, dass man nur eine begrenzte Anzahl von Nachrichten mit dem Kia BEV pro Tag austauschen kann. Das wurde im DOIF schon etwas berücksichtigt (1x pro Stunde), kann jedoch bei gleichzeitiger Verwendung der Handy App oder der SOC Abfrage im openWB Kia Modul auch mal zu Fehlern führen. Durch die Stündliche Status Abfrage im DOIF kommt es natürlich zu Verzögerungen im FHEM Status. Dann einfach einmal Manuell abfragen.

Node-red JSON Import
<syntaxhighlight lang="json">
[ {
"id": "866c75dd.edd9a8",
"type": "tab",
"label": "Kia e-Niro",
"disabled": false,
"info": ""
},
{
"id": "bb13a99d.68b8f8",
"type": "mqtt-broker",
"name": "mqtt_Server",
"broker": "<FHEM MQTT IP Adresse>",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"compatmode": false,
"protocolVersion": "4",
"keepalive": "60",
"cleansession": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"sessionExpiry": ""
},
{
"id": "452a3304.58c8fc",
"type": "bluelinky",
"username": "<Mail Adresse bei Kia>",
"password": "<Passwort>",
"region": "EU",
"pin": "<Pin>",
"vin": "<VIN>",
"brand": "kia"
},
{
"id": "91a345fa.5757a8",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_status",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 260,
"y": 280,
"wires": [
[
"15dfb508.c6497b",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "5ad085b9.05739c",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/start_climate",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 680,
"wires": [
[
"b27d74de.38c808",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "15dfb508.c6497b",
"type": "car-status",
"z": "866c75dd.edd9a8",
"name": "Get status",
"dorefresh": true,
"parsed": false,
"bluelinky": "452a3304.58c8fc",
"x": 1110,
"y": 280,
"wires": [
[
"cccc9476.d56dd8",
"226ed925.607bb6"
]
]
},
{
"id": "87abdd88.8ff4d",
"type": "car-odometer",
"z": "866c75dd.edd9a8",
"name": "Get car odometer",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 200,
"wires": [
[
"40d2361c.579588",
"226ed925.607bb6"
]
]
},
{
"id": "31100f9a.40008",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "locationWrapper",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"location\": msg.payload,\n \"error\": false\n };\n \n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 1490,
"y": 120,
"wires": [
[
"85a07155.a0f9f",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "bea1d927.0f3908",
"type": "car-location",
"z": "866c75dd.edd9a8",
"name": "Get car location",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 120,
"wires": [
[
"31100f9a.40008",
"226ed925.607bb6"
]
]
},
{
"id": "3c949d67.0d83b2",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_location",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 120,
"wires": [
[
"bea1d927.0f3908",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "cccc9476.d56dd8",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "analyseStatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n let status = msg.payload;\n status.airTemp.value = 14+(parseInt(status.airTemp.value,16)/2);\n try{\n status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n } catch(e) {}\n\n let time = status.evStatus.remainTime2.atc.value/60;\n let result = { \n \"batSOC\": status.evStatus.batteryStatus,\n \"connected\": (status.evStatus.batteryPlugin !== 0),\n \"charging\": status.evStatus.batteryCharge,\n \"targetSOC\": status.evStatus.reservChargeInfos.targetSOClist[1].targetSOClevel,\n \"time2targetSOC\": (Math.floor(time) + \":\" + (\"0\" + Math.floor((time % 1)*60)).slice(-2)), // h:mm\n \"range\": status.evStatus.drvDistance[0].rangeByFuel.totalAvailableRange.value,\n \"bat12v\": status.battery.batSoc\n };\n \n //msg.payload = result;\n msg.payload = {\n \"status\": status,\n \"error\": false\n \n };\n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1480,
"y": 280,
"wires": [
[
"3efceea0.c81b12",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "85a07155.a0f9f",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/location",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1910,
"y": 120,
"wires": []
},
{
"id": "3efceea0.c81b12",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/status",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1900,
"y": 280,
"wires": []
},
{
"id": "327104fc.71e1bc",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/odometer",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1910,
"y": 200,
"wires": []
},
{
"id": "844a32f4.2e029",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/stop_climate",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 270,
"y": 760,
"wires": [
[
"7d3ae860.d8c9a8",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "57d91e50.7e96",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/start_charging",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 280,
"y": 820,
"wires": [
[
"6eebc52c.ee23dc",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "6029f0a0.b73e",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/stop_charging",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 280,
"y": 880,
"wires": [
[
"84a1ae.74912e5",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "c5ecf76c.e753c8",
"type": "start-car",
"z": "866c75dd.edd9a8",
"name": "Start car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 680,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "6eebc52c.ee23dc",
"type": "start-charge",
"z": "866c75dd.edd9a8",
"name": "Start Charging",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 820,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "84a1ae.74912e5",
"type": "stop-charge",
"z": "866c75dd.edd9a8",
"name": "Stop Charging",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 880,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "7d3ae860.d8c9a8",
"type": "stop-car",
"z": "866c75dd.edd9a8",
"name": "Stop car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 760,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "b27d74de.38c808",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "obj",
"pretty": false,
"x": 750,
"y": 680,
"wires": [
[
"c5ecf76c.e753c8",
"33b1bc85.662694"
]
]
},
{
"id": "45a6a8e6.2abfd8",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_odometer",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 280,
"y": 200,
"wires": [
[
"87abdd88.8ff4d",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "33b1bc85.662694",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 930,
"y": 920,
"wires": []
},
{
"id": "ce62ba4f.d86548",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/req_received",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 860,
"y": 480,
"wires": []
},
{
"id": "1babee6c.1c2982",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_all",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 250,
"y": 360,
"wires": [
[
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2",
"4375fbb9.00fb44"
]
]
},
{
"id": "262df5dc.57916a",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1850,
"y": 80,
"wires": []
},
{
"id": "811aa567.e89f98",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1470,
"y": 1040,
"wires": []
},
{
"id": "3f82a275.5a0b6e",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 930,
"y": 80,
"wires": []
},
{
"id": "24d5e0b.3aafc2",
"type": "change",
"z": "866c75dd.edd9a8",
"name": "",
"rules": [
{
"t": "set",
"p": "payload",
"pt": "msg",
"to": "pending",
"tot": "str"
}
],
"action": "",
"property": "",
"from": "",
"to": "",
"reg": false,
"x": 790,
"y": 1140,
"wires": [
[
"4dd1ea4a.52f144",
"fecad185.324f8"
]
]
},
{
"id": "f487d6d6.a4d568",
"type": "change",
"z": "866c75dd.edd9a8",
"name": "",
"rules": [
{
"t": "set",
"p": "payload",
"pt": "msg",
"to": "idle",
"tot": "str"
}
],
"action": "",
"property": "",
"from": "",
"to": "",
"reg": false,
"x": 1910,
"y": 760,
"wires": [
[
"4dd1ea4a.52f144",
"fecad185.324f8"
]
]
},
{
"id": "4dd1ea4a.52f144",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/req_active",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 2140,
"y": 1100,
"wires": []
},
{
"id": "fecad185.324f8",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "false",
"statusVal": "",
"statusType": "auto",
"x": 2110,
"y": 1160,
"wires": []
},
{
"id": "40d2361c.579588",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "odometerWrapper",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n msg.payload = { \n \"odometer\": msg.payload,\n \"error\": false\n };\n\n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 1490,
"y": 200,
"wires": [
[
"327104fc.71e1bc",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "226ed925.607bb6",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1430,
"y": 80,
"wires": []
},
{
"id": "4375fbb9.00fb44",
"type": "car-fullstatus",
"z": "866c75dd.edd9a8",
"name": "Get full status",
"dorefresh": true,
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 360,
"wires": [
[
"226ed925.607bb6",
"69b6c4df.ea6bcc",
"89681a97.9e24d8",
"92dc3ff4.1d6e3"
]
]
},
{
"id": "69b6c4df.ea6bcc",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "locationFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"location\": msg.payload.vehicleLocation,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1500,
"y": 360,
"wires": [
[
"85a07155.a0f9f",
"331e5860.907808"
]
]
},
{
"id": "92dc3ff4.1d6e3",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "statusFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n let status = msg.payload.vehicleStatus;\n try{\n status.airTemp.value = 14+(parseInt(status.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n } catch(e) {}\n\n msg.payload = { \n \"status\": status,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1500,
"y": 480,
"wires": [
[
"3efceea0.c81b12",
"f487d6d6.a4d568",
"331e5860.907808"
]
]
},
{
"id": "89681a97.9e24d8",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "odometerFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"odometer\": msg.payload.odometer,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1510,
"y": 420,
"wires": [
[
"327104fc.71e1bc",
"331e5860.907808"
]
]
},
{
"id": "331e5860.907808",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1850,
"y": 520,
"wires": []
},
{
"id": "aa4d220b.f7e19",
"type": "set-chargetargets",
"z": "866c75dd.edd9a8",
"name": "Set charge targets",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 960,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "4c03338d.2f15ec",
"type": "login",
"z": "866c75dd.edd9a8",
"name": "Login",
"bluelinky": "452a3304.58c8fc",
"x": 1090,
"y": 1040,
"wires": [
[
"811aa567.e89f98"
]
]
},
{
"id": "28b868f5.16cb48",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "43200",
"crontab": "",
"once": true,
"onceDelay": "12",
"topic": "",
"payloadType": "date",
"x": 950,
"y": 1040,
"wires": [
[
"4c03338d.2f15ec"
]
]
},
{
"id": "db9ecdb5.a9683",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/set_chargetargets",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 290,
"y": 960,
"wires": [
[
"7064a8d53256b646",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "44155ad70c47b0dd",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 260,
"wires": [
[
"15dfb508.c6497b"
]
]
},
{
"id": "7064a8d53256b646",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "obj",
"pretty": false,
"x": 750,
"y": 960,
"wires": [
[
"33b1bc85.662694",
"aa4d220b.f7e19"
]
]
},
{
"id": "7064395e56292844",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 340,
"wires": [
[
"4375fbb9.00fb44"
]
]
},
{
"id": "5f9ff828080f5fe6",
"type": "lock-car",
"z": "866c75dd.edd9a8",
"name": "Lock car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 560,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "492f5b94a865e47b",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 540,
"wires": [
[
"5f9ff828080f5fe6"
]
]
},
{
"id": "d6f3f148e765caf9",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/car_lock",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 260,
"y": 560,
"wires": [
[
"5f9ff828080f5fe6",
"ce62ba4f.d86548"
]
]
},
{
"id": "cdc13a486db22b8e",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/car_unlock",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 620,
"wires": [
[
"99f5c3a41ac3e754",
"ce62ba4f.d86548"
]
]
},
{
"id": "99f5c3a41ac3e754",
"type": "unlock-car",
"z": "866c75dd.edd9a8",
"name": "Unlock car",
"bluelinky": "452a3304.58c8fc",
"x": 1110,
"y": 620,
"wires": [
[
"f487d6d6.a4d568",
"811aa567.e89f98"
]
]
},
{
"id": "ab557a0ea621403a",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 600,
"wires": [
[
"99f5c3a41ac3e754"
]
]
},
{
"id": "a525de86e4374518",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 740,
"wires": [
[
"7d3ae860.d8c9a8"
]
]
},
{
"id": "0b8cb92c042fe140",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 800,
"wires": [
[
"6eebc52c.ee23dc"
]
]
},
{
"id": "ae4c2139b08aaa28",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 860,
"wires": [
[
"84a1ae.74912e5"
]
]
},
{
"id": "dd23108ce63f456d",
"type": "get-monthlyreport",
"z": "866c75dd.edd9a8",
"name": "Get monthly report",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 1280,
"wires": [
[
"e57eb97531129426"
]
]
},
{
"id": "a6e5e8deb52145f1",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 1260,
"wires": [
[
"dd23108ce63f456d"
]
]
},
{
"id": "95f1b6f32aafd65b",
"type": "get-tripinfo",
"z": "866c75dd.edd9a8",
"name": "Tripinfo",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 1220,
"wires": [
[
"e57eb97531129426"
]
]
},
{
"id": "fb2b99958bc48593",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "",
"pretty": false,
"x": 750,
"y": 1220,
"wires": [
[
"95f1b6f32aafd65b"
]
]
},
{
"id": "5230ebe391325b17",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_tripinfo",
"qos": "2",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 270,
"y": 1220,
"wires": [
[
"fb2b99958bc48593"
]
]
},
{
"id": "e57eb97531129426",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1470,
"y": 1220,
"wires": []
},
{
"id": "4fdf3b1b7811c89f",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_tripinfo",
"qos": "2",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 270,
"y": 1280,
"wires": [
[
"dd23108ce63f456d"
]
]
}
]
</syntaxhighlight>

=====Kia_eNiro_PV DOIF mit uiTable=====
Mit diesem DOIF Device werden folgende Funktionalitäten abgebildet:
Nun dann noch das DOIF mit dem uiTable für die Status Anzeige und die Steuerung über Pull Down Menüs.

- Status Abfrage
Status jede Stunde zwischen 6 und 23 Uhr (12V min 40%)
Status beim Laden alle 15 Minuten (12V min 40%)
Anzeige des Kilometerzählers
Status des Fahrzeuges zu Hause / unterwegs und beim Laden
Fahrzeug Auf/Zu

- Klimatisierung über das Pull Down Menü
unterschiedliche Temperaturen für Heizen und Kühlen
Aktuelle Temperatur
Heizen/Klima Ein/Aus
Timer für zeitgesteuertes Klimatisieren für den Resttag oder den Nächsten Tag (vor der aktuellen Zeit)
Klimatisierung über "Abfall" Kalender (es geht nur ein Termin pro Tag, dafür aber komfortabel über das Handy)

- Komfort
Reifen Überwachung
Türen / Motorhaube / Kofferraum Überwachung
12V Batterie anzeige, wenn der Ladezustand kleiner 40% ist erfolgt keine weitere Status Abfrage

- ACCU Steuerung
Setzen des Ziel SOC beim Standard Laden
Start/Stop Laden
Accu Stand und berechnete Restkilometer

- Für openWB integratin im uiTable
Wählen des Lademodus
Vorrang EV oder Bat
Sperren des Hausspeichers entweder manuell oder automatisch beim Laden. Der vorherige Zustand wird gespeichert
Die Freigabe erfolgt über die Wechselrichter Implementierung, siehe dort [[Kostal_Plenticore_10_Plus#Externe_Speichersteuerung_.28ExternControl.29|"Externe Speicher Steuerung"]]
Geschätzte Ladezeit
Status Ladepunkt (Plug und Laden)
Lade Status Phasen und Leistung

'''Achtung, die Kia connect Abfragen sind auf ca. 200 pro Tag von Kia limitiert! Durch die Stündliche Status Abfrage im DOIF kommt es natürlich zu Verzögerungen im FHEM Status. Dann einfach einmal manuell abfragen.'''

Die Kommunikation zum Kia BEV ist manchmal sehr träge, z.B. kann eine Status Abfrage auch mal 3 Minuten dauern, deshalb wurde eine Verriegelung implementiert. Es wird ein Status pending/idle angezeigt. Nur wenn der Zustand "idel" ist, können weitere Abfragen gestartet werden. Läuft z.B. die Status Abfrage kann man ein weiteres Kommando anstarten, es wird jedoch erst abgesetzt, wenn das vorherige Kommando fertig ist. Solange bleibt im Pull Down Menü das neue Kommando stehen.

RAW des DOIF
<syntaxhighlight lang="Perl">
defmod Kia_eNiro_PV DOIF ################################################################################################################\
## 1 Kia Connect Status Abfrage erfolgt mit MQTT2 ==> node-ret ==> Kia Connect\
##\
1_Status_getAll\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( ([+00:15] and ## alle 15 Minuten\
[Kia_connect:atHomeStanding] eq "true" and ## wenn das Auto zuhause ist\
[Kia_connect:charging] eq "true" or ## und es geladen wird\
[:58] and [05:00-23:00] ## ansonsten nur jede Stunde\
) and [Kia_connect:bat12v] > 40 ## aber die 12V Batterie sollte noch genügend Ladung haben\
or [$SELF:cmd_event] eq "set_cmd_1" ## Das reagiert auf den Aufruf mit "set <Device> cmd_*"\
or [$SELF:ui_command_1] eq "Status_getAll" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "Status_getAll" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_before_1",[$SELF:ui_command_1]);;\
}\
\
fhem_set("Kia_connect getAll");; ## beliebige Kommandos für diesen Block\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
2_Klima\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_2] eq "stopClimate" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_2] eq "startHeating"\
or [$SELF:ui_command_2] eq "startCooling"\
)\
) {\
set_Reading("ui_command_before_2",[$SELF:ui_command_2]);;\
\
if ([$SELF:ui_command_2] eq "startHeating") {\
my $airTemp_value= [Kia_connect:status_airTemp_value_target_Winter];;\
fhem_set('Kia_connect startClimate {"defrost": true, "windscreenHeating": true, "temperature": '.$airTemp_value.' , "unit": "C"}');;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : startHeating"};;\
}\
if ([$SELF:ui_command_2] eq "startCooling") {\
my $airTemp_value = [Kia_connect:status_airTemp_value_target_Summer];;\
fhem_set('Kia_connect startClimate {"defrost": false, "windscreenHeating": false, "temperature": '.$airTemp_value.' , "unit": "C"}');;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : startCooling"};;\
}\
if ([$SELF:ui_command_2] eq "stopClimate") {\
fhem_set("Kia_connect ".[$SELF:ui_command_2]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : stopClimate"};;\
}\
fhem_set("Abfall update");;\
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
3_Laden\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_3] eq "setChargeTargetSoc" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_3] eq "startCharge"\
or [$SELF:ui_command_3] eq "stopCharge"\
)\
) {\
set_Reading("ui_command_before_3",[$SELF:ui_command_3]);;\
\
if ([$SELF:ui_command_3] eq "setChargeTargetSoc") {\
my $targetSOClist_1_targetSOClevel = [Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_1_targetSOClevel_target];;\
my $targetSOClist_2_targetSOClevel = [Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel_target];;\
fhem_set("Kia_connect setChargeTargetSoc {\"fast\": ".$targetSOClist_1_targetSOClevel.", \"slow\": ".$targetSOClist_2_targetSOClevel."}");;\
} else {\
fhem_set("Kia_connect ".[$SELF:ui_command_3]);; ## beliebige Kommandos für diesen Block\
}\
\
set_Reading("ui_command_3","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
4_Klima_timer_heizen\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [[Abfall_Abfuhr:Kiaheizen_connect_time]] ## Prüfe den Kalender Eintrag\
and [Abfall_Abfuhr:Kiaheizen_connect_date] eq $ymd ## ist es heute?\
)\
or\
( [$SELF:ui_timer_mode] eq "heizen" ## Timer zum Heizen aktiv?\
and [[$SELF:ui_timer_Start]] ## ist es soweit?\
)\
)\
) {\
\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 4_Klima_timer : startHeating"};;\
set_Reading("ui_timer_mode","Aus");; ## Schalte die Timer Funktion ab\
set_Reading("ui_command_2","startHeating");; ## Es soll geheizt werden\
fhem_set("$SELF 2_Klima");; ## Aktiviere das Heizen\
\
}\
}\
\
5_Klima_timer_kuehlen\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [[Abfall_Abfuhr:Kiakuehlen_connect_time]] ## Prüfe den Kalender Eintrag\
and [Abfall_Abfuhr:Kiakuehlen_connect_date] eq $ymd ## ist es heute?\
)\
or\
( [$SELF:ui_timer_mode] eq "kuehlen" ## Timer zum Kühler aktiv?\
and [[$SELF:ui_timer_Start]] ## ist es soweit?\
)\
)\
) {\
\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 4_Klima_timer : startCooling"};;\
set_Reading("ui_timer_mode","Aus");; ## Schalte die Timer Funktion ab\
set_Reading("ui_command_2","startCooling");; ## Es soll gekühlt werden\
fhem_set("$SELF 2_Klima");; ## Aktiviere das Kühlen\
\
}\
}\
\
6_Auf_Zu\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_2] eq "car_lock" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_2] eq "car_unlock"\
)\
) {\
set_Reading("ui_command_before_2",[$SELF:ui_command_2]);;\
\
fhem_set("Kia_connect ".[$SELF:ui_command_2]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 6_Auf_Zu : ".[$SELF:ui_command_2]};;\
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
7_WB_1_lp_1\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:ui_command_4] eq "SofortLaden" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_4] eq "Min+PV"\
or [$SELF:ui_command_4] eq "NurPV"\
or [$SELF:ui_command_4] eq "Stop"\
or [$SELF:ui_command_4] eq "Standby"\
or [$SELF:ui_command_4] eq "Vorrang_EV"\
or [$SELF:ui_command_4] eq "Vorrang_Bat"\
)\
) {\
set_Reading("ui_command_before_4",[$SELF:ui_command_4]);;\
\
if ([$SELF:ui_command_4] eq "Vorrang_Bat" or [$SELF:ui_command_4] eq "Vorrang_EV") {\
if ([$SELF:ui_command_4] eq "Vorrang_EV") {\
fhem_set("WB_1 priorityModeEVBattery 1");;\
} else {\
fhem_set("WB_1 priorityModeEVBattery 0");;\
}\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 7_WB_1_lp_1 : ".[$SELF:ui_command_4]};;\
} else {\
fhem_set("WB_1 Lademodus ".[$SELF:ui_command_4]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 7_WB_1_lp_1 : Lademodus ".[$SELF:ui_command_4]};;\
}\
\
set_Reading("ui_command_4","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
8_Speicher_sperren\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:ui_command_4] eq "Hausspeicher_Sperren" ## Hier wird das uiTable select ausgewertet\
or [WB_1:lp_1_ChargeStat] eq "loading" and\
[WB_1:lp_1_PlugStat] eq "Plugged in"\
)\
) {\
set_Reading("ui_command_before_4",[$SELF:ui_command_4]);;\
\
if([$SELF:WR_1_Speicher_1_ExternControl_smart_laden_before] eq "---") {\
\
if([$SELF:SpeicherExternTrigger] eq "gesperrt" and\
[WR_1_API:Battery_InternControl_MinHomeConsumption] eq "30000" ) {\
set_Reading("WR_1_Speicher_1_ExternControl_smart_laden_before","aktiv");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_laden_before aktiv"};;\
} else {\
set_Reading("WR_1_Speicher_1_ExternControl_smart_laden_before","inaktiv");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_laden_before inaktiv"};;\
}\
\
fhem_set("WR_1_Speicher_1_ExternControl cmd_2");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_Laden startet"};;\
}\
\
set_Reading("ui_command_4","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
9_WB_1_Zaehler_Statistiken\
{if( !([$SELF:state] eq "off") and ## DOIF enabled\
[00:01]\
) {\
fhem("setreading WB_1 lp_1_kWhCounter_init_Day ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Day ".[WB_1:lp_2_kWhCounter]);;\
\
if ($mday eq 1)\
{\
fhem("setreading WB_1 lp_1_kWhCounter_init_Month ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Month ".[WB_1:lp_2_kWhCounter]);;\
\
if ($yday eq 0)\
{\
fhem("setreading WB_1 lp_1_kWhCounter_init_Year ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Year ".[WB_1:lp_2_kWhCounter]);;\
}\
}\
}\
}
attr Kia_eNiro_PV DbLogExclude .*
attr Kia_eNiro_PV disable 0
attr Kia_eNiro_PV group PV Eigenverbrauch-Steuerung
attr Kia_eNiro_PV icon car
attr Kia_eNiro_PV room Strom->Photovoltaik
attr Kia_eNiro_PV sortby 401
attr Kia_eNiro_PV uiTable {\
package ui_Table;;\
## $TR{0} = "style='color:yellow;;text-align:left;;font-weight:bold;;font-size:18px'";; ## Reihe 0 für Überschrift\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_batt {\
my($val)=@_;;\
my $ret="position:absolute;;left:".(90*$val/100)."px;;width:90px;;height:20px;;background:linear-gradient( to right,#F8F8E0 ".(90-(90*$val/100))."px,rgba(0,0,0,0) ".(90-(90*$val/100))."px);;";;\
return $ret;;\
}\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
sub FUNC_Status_Laden {\
my($car)=@_;;\
my $charge = (::ReadingsVal($car,"charging","false") eq "true");;\
my $athome = (::ReadingsVal($car,"atHomeStanding","false") eq "true");;\
my $chargeathome = ($charge && $athome);;\
my $connectedathome = ($athome && ::ReadingsVal($car,"connected","false") eq "true");;\
\
my $ret = ($chargeathome ? "lädt zu Hause" : ($connectedathome ? "angeschlossen zu Hause" : ($athome ? "zu Hause" : ($charge ? "Lädt auswärts" : "unterwegs"))));;\
return $ret;;\
}\
sub FUNC_tire {\
my($car)=@_;;\
my $ret = 'Reifendruck okay';;\
\
if (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampAll","1") != 0) {\
my $VL = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampFL","1") eq "0")?0:1;;\
my $HL = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampRL","1") eq "0")?0:1;;\
my $VR = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampFR","1") eq "0")?0:1;;\
my $HR = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampRR","1") eq "0")?0:1;;\
$ret = 'Reifen Störung ';;\
if ($VL == 1){$ret.=' /VL'};;\
if ($VR == 1){$ret.=' /VR'};;\
if ($HL == 1){$ret.=' /HL'};;\
if ($HR == 1){$ret.=' /HR'};;\
$ret = $ret.'';;\
}\
return $ret;;\
}\
sub FUNC_door {\
my($car)=@_;;\
my $ret = 'Türen okay ';;\
\
if (::ReadingsVal($car,"status_doorLock","false") ne "true") {\
my $VL = (::ReadingsVal($car,"status_doorOpen_frontLeft",1) == 0)?0:1;;\
my $HL = (::ReadingsVal($car,"status_doorOpen_backLeft",1) == 0)?0:1;;\
my $VR = (::ReadingsVal($car,"status_doorOpen_frontRight",1) == 0)?0:1;;\
my $HR = (::ReadingsVal($car,"status_doorOpen_backRight",1) == 0)?0:1;;\
$ret = 'Tür offen ';;\
if ($VL == 1){$ret.=' /VL'};;\
if ($VR == 1){$ret.=' /VR'};;\
if ($HL == 1){$ret.=' /HL'};;\
if ($HR == 1){$ret.=' /HR'};;\
$ret = $ret.'';;\
}\
if (::ReadingsVal($car,"status_trunkOpen","true") eq "true") {\
$ret.=' Kofferraum offen';;\
}\
if (::ReadingsVal($car,"status_hoodOpen","true") eq "true") {\
$ret.=' Motorhaube offen';;\
}\
return $ret;;\
}\
}\
\
"$SELF"|"Kommando ".::ReadingsTimestamp("Kia_connect","status_time","")."<dd>Auswahl / Kommunikation / Tacho / Info Status</dd>" | widget([$SELF:ui_command_1],"uzsuDropDown,---,Status_getAll,car_lock,car_unlock")|(([Kia_connect:req_active] eq "idle")?'idle' : ''.[Kia_connect:req_active].'') |::round([Kia_connect:odometer_value],0)." km"|FUNC_Status_Laden("Kia_connect")\
\
|"Accu<dd>Steuerung / Target Soc / Accu Status</dd>" |widget([$SELF:ui_command_3],"uzsuDropDown,---,setChargeTargetSoc,stopCharge,startCharge")|"Target SOC".widget([Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel_target],"selectnumbers,50,10,100,0,lin")." %"|""| FUNC_Status([Kia_connect:range],150,"red",[Kia_connect:range],"orange",[Kia_connect:range],250,"green",[Kia_connect:range])." km"."<div style='border-width:2px;;border-style:solid;;border-color:gray;;position:relative;;width:90px;;height:20px;;background:linear-gradient( to right, red 0px,yellow 30px,green 50px);;'>".STY(" ",FUNC_batt([Kia_connect:batSOC])).STY(::round([Kia_connect:batSOC],0)."%","font-size:16px;;position:absolute;;top:2px;;left:30px")."</div>"\
\
|"Komfort<dd>Timer / Klima / Reifen / Türen / Accu Status 12V</dd>" |widget([$SELF:ui_timer_mode],"uzsuDropDown,Aus,heizen,kuehlen").widget([$SELF:ui_timer_Start],"time")|\
((::ReadingsVal("Abfall_Abfuhr","Kiaheizen_days",0) != 0)?"Klimatisierung ".[Abfall_Abfuhr:Kiaheizen_connect_date]." ".[Abfall_Abfuhr:Kiaheizen_connect_time]:(([$SELF:ui_timer_mode] ne "Aus")?"Klimatisierung ".[$SELF:timer_04_c04]:""))|FUNC_tire("Kia_connect")." ".FUNC_door("Kia_connect")|\
"12 V<div style='border-width:2px;;border-style:solid;;border-color:gray;;position:relative;;width:90px;;height:20px;;background:linear-gradient( to right, red 0px,yellow 30px,green 50px);;'>".STY(" ",FUNC_batt([Kia_connect:bat12v])).STY(::round([Kia_connect:bat12v],0)."%","font-size:16px;;position:absolute;;top:2px;;left:30px")."</div>"\
\
|"<dd> Auswahl / Temperatur / Klima Status / Temperatur innen</dd>"| widget([$SELF:ui_command_2],"uzsuDropDown,---,stopClimate,startHeating,startCooling")|\
"Heat".widget([Kia_connect:status_airTemp_value_target_Winter],"selectnumbers,20,1,27,0,lin")."°C Cool".widget([Kia_connect:status_airTemp_value_target_Sommer],"selectnumbers,16,1,25,0,lin")."°C"|(([Kia_connect:status_airCtrlOn] eq "true")?'Klima läuft':'Klima aus')." ".(([Kia_connect:status_defrost] eq "true")?'Defrost ein':'Defrost aus') |"Aktuell ".[Kia_connect:status_airTemp_value]."°C"\
\
|"WallBox (WB_1_lp1)<dd>Lademodus / Info Status / Ladezeit / Leistung</dd>"|[WB_1:ChargeMode]." ".widget([$SELF:ui_command_4],"uzsuDropDown,---,SofortLaden,Min+PV,NurPV,Stop,Standby,Vorrang_EV,Vorrang_Bat,Hausspeicher_Sperren")|[WB_1:lp_1_PlugStat]." ".[WB_1:lp_1_ChargeStat]|[WB_1:lp_1_TimeRemaining]|[WB_1:lp_1_countPhasesInUse]."P ".[WB_1:lp_1_AConfigured]."A ".[WB_1:lp_1_W]." W"

setstate Kia_eNiro_PV 2022-01-12 13:24:24 ui_command_1 ---
setstate Kia_eNiro_PV 2022-01-10 09:18:53 ui_command_2 ---
setstate Kia_eNiro_PV 2021-11-09 07:56:54 ui_command_3 ---
setstate Kia_eNiro_PV 2022-01-12 13:02:41 ui_command_4 ---
setstate Kia_eNiro_PV 2022-01-12 13:02:41 ui_command_before_4 ---
setstate Kia_eNiro_PV 2021-11-29 09:56:58 ui_timer_Start 10:30
setstate Kia_eNiro_PV 2021-12-02 07:00:00 ui_timer_mode Aus
</syntaxhighlight>

=====Kostal Plenticore mit Speicher=====
Zu diesem Thema gibt es noch die Wiki Seite [[Kostal Plenticore Plus]], die alles rund um den Wechselrichter und vieles mehr erklärt.
Die hier beschriebene openWB und Kia connect Anbindung bedient sich der Hausspeichersteuerung, um diesen beim Laden der BEV zu sperren.
Im DOIF kann an den entsprechenden Stellen natürlich auch ein anders Kommando zum Sperren verwendet werden.

== Weiterführende Links ==
* [https://openwb.de openWB Website]
* [https://github.com/snaptec/openWB/wiki openWB Wiki bei GitHub]
* [https://www.openwb.de/forum/viewtopic.php?f=6&t=4159 openWB Forum (Diskussion zu diesem Artikel)]
* [https://openwb.de/forum/viewtopic.php?t=577 openWB Forum (Liste der MQTT-Topics)]

[[Kategorie:Elektromobilität]]
[[Kategorie:HOWTOS]]
[[Kategorie:Wallboxen]]

OpenWB

2025-01-12T15:53:15Z

Ch.eick: /* Kia_eNiro_PV DOIF mit uiTable */

== Integration der openWB in FHEM - Ladeleistung anzeigen und Umschalten des Lademodus ==
Ausgangssituation ist ein funktionierendes FHEM, ohne weitere Vorbedingungen.<syntaxhighlight lang="perl">
defmod openwb MQTT <openWBip>:1883
attr openwb room Auto,MQTT

</syntaxhighlight>Dadurch wird der MQTT-Server der openWB angesprochen, FHEM ist der Client.

Ein Ladepunkt wird als MQTT_Device angelegt:<syntaxhighlight lang="perl">
defmod lp1 MQTT_DEVICE
attr lp1 IODev openwb
attr lp1 publishSet_chargeMode openWB/set/ChargeMode
attr lp1 room Auto,Dashboard,MQTT
attr lp1 stateFormat power
attr lp1 subscribeReading_chargeMode openWB/global/ChargeMode
attr lp1 subscribeReading_plugStat openWB/lp/1/boolPlugStat
attr lp1 subscribeReading_power openWB/lp/1/W
</syntaxhighlight>Die Umsetzung basiert auf openWB 1.9.x, der Lademodus "ChargeMode" gilt hier noch global für alle Ladepunkte.

Beispielhaft die Definition des zweiten Ladepunktes, eine zweite openWB, die als "nur Ladepunkt" mit der angesprochenen openWB verbunden ist.

Eine openWB kann derzeit 8 Ladepunkte verwalten, die Nummern müssen entsprechend inkrementiert werden.<syntaxhighlight lang="perl">
defmod lp2 MQTT_DEVICE
attr lp2 IODev openwb
attr lp2 publishSet_chargeMode openWB/set/ChargeMode
attr lp2 room Auto,Dashboard,MQTT
attr lp2 stateFormat power
attr lp2 subscribeReading_chargeMode openWB/global/ChargeMode
attr lp2 subscribeReading_plugStat openWB/lp/2/boolPlugStat
attr lp2 subscribeReading_power openWB/lp/2/W
</syntaxhighlight>Die MQTT-Topics zum Lesen und Schreiben von Werten sind ganz unten auf dieser Wiki-Seite zu finden.

Die Einbindung in die TabletUI sieht bei mir so aus:
[[Datei:Ladepunkte in TabletUI.png|alternativtext=Darstellung der openWB Ladepunkte in der TabletUI|mini|488x488px|Beispielhafte Darstellung in der TabletUI]]
[[Datei:Auswahl des Lademodus.png|alternativtext=Darstellung der openWB Ladepunkte in der TabletUI - Auswahl des Lademodus|mini|486x486px|Auswahl des Lademodus per CircleMenu]]
<syntaxhighlight lang="html">
<div class="cell-60 left-space right-space">
<div data-type="symbol" data-icon="fa-car" class="tall compressed" data-color="lightgray">
<div data-type="circlemenu" data-direction="full" class="mini" style="top: -0.5em;">
<ul class="mini">
<li><div data-type="push" data-device="lp1" data-get="chargeMode" data-states='[0,1,2,3,4]' data-colors='["lightgreen","greenyellow","yellow","grey","black"]' data-icons='["fa-bolt","fa-plus-circle","fa-sun-o","fa-pause-circle-o","fa-stop-circle-o"]' data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="0" data-get-on="0" data-icon="fa-bolt" data-color="lightgreen" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="1" data-get-on="1" data-icon="fa-plus-circle" data-color="greenyellow" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="2" data-get-on="2" data-icon="fa-sun-o" data-color="yellow" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="3" data-get-on="3" data-icon="fa-pause-circle-o" data-color="grey" data-background-icon=""></div></li>
<li><div data-type="push" data-device="lp1" data-set="chargeMode" data-get="chargeMode" data-set-on="4" data-get-on="4" data-icon="fa-stop-circle-o" data-color="black" data-background-icon=""></div></li>
</ul>
</div>
<div style="font-size: 30% !important;" class="mini " data-pre-text="" data-type="label" data-device="lp1" data-get="power" data-unit="" data-factor="1" data-fix="0"></div>
<div data-type="symbol" data-device="lp1" data-get="plugStat" data-states='[0,1]' data-colors='["white","black"]' data-icons='["","fa-plug"]' data-background-icon="" class="mini" style="font-size: 30% !important; top:1em;"></div></li>
</div>
</div>

</syntaxhighlight>

==Integration OpenWB in FHEM - Übertragung von EVU, PV und Batteriewerten an openWB==
Ausgangssituation ist ein funktionierendes FHEM-System, bei dem bereits der digitale Stromzähler ("Moderne Meßeinrichtung") über das Modul 47_OBIS und der PV-Wechselrichter über ein entsprechendes Modul, z.B. ModbusAttr integriert sind. Als OpenWB-System wurde hier eine reale OpenWB-Wallbox angebunden.

=== Datenquellen ===
Die OpenWB erwartet 1-3 Typen von Datenquellen in dieser Konstellation:
* Die ''EVU-''Schnittstelle, mit der als wesentlicher Steuerparameter der Ladeleistung die Leistungsmessung am Hausübergang herangezogen wird, und daneben die Zählerwerte für Netzbezug und Einspeisung zur Visualisierung übertragen werden sollten. Nur, falls phasenbezogenes Lastmanagement erforderlich sein sollte, sind auch die einzelnen Phasenleistungswerte vom Stromzähler nötig (was nicht jede Moderne Meßeinrichtung auf der OBIS-Schnittstelle bereitstellt)
* Die ''PV-''Schnittstelle, die ebenfalls primär visualisierende Bedeutung hat.
* Die ''Batteriespeicher-''Schnittstelle
OpenWB kann auch z.B. rein mit einer PV-Schnittstelle betrieben werden, in diesem Fall wird ein konstanter Leistungswert für den Hausbezug angenommen.

=== Kommunikationsprotokoll ===
Zur Kommunikation mit FHEM bieten sich 2 Methoden an:
* '''HTTP'''-Abfrage durch OpenWB bei FHEM durch das generische HTTP-Modul von OpenWB Diese Methode beschreibe ich nicht, weil sie mehr Overhead erzeugt und seitens FHEM die Einrichtung eines CSRF-Token-freien Web-Kanals erfordert
* '''MQTT'''-Push durch FHEM zur OpenWB Diese Methode erscheint mir vorteilhafter, weil auf einer stehenden TCP-Verbindung lediglich Meßwerte gepusht werden.

=== Implementierung ===

==== Vorbereitung ====
In der OpenWB-Web-UI unter Modulkonfiguration die entsprechenden Module (EVU, PV, Batterie) auf MQTT stellen. Hinweis: Nicht alle dabei erscheinenden MQTT-Topics müssen mit Werten beliefert werden! Sowohl bei der EVU-Schnittstelle wie bei PV reichen Momentanleistung und Zählerstände für eine zufriedenstellende Anbindung!

==== Definition der OpenWB als MQTT-Target ====
defmod openwb_mqtt MQTT2_CLIENT <ip-der-openwb>:1883
attr openwb_mqtt autocreate simple
attr openwb_mqtt subscriptions openWB/lp/1/#

==== Übertragung der EVU-Meßwerte ====
In diesem Beispiel heißt das die Stromzählerdaten liefernde Device am OBIS-Modul "MT175". Die Zahlen werden per Notify von diesem Device auf MQTT kopiert:
defmod openwb_evu_cons notify MT175:total_consumption:.* { fhem("set openwb_mqtt publish openWB/set/evu/WhImported " . $EVTPART1); }
defmod openwb_evu_feed notify MT175:total_feed:.* { fhem("set openwb_mqtt publish openWB/set/evu/WhExported " . $EVTPART1); }
defmod openwb_evu_w notify MT175:power:.* { fhem("set openwb_mqtt publish openWB/set/evu/W " . int($EVTPART1)); }

==== Übertragung der PV-Meßwerte ====
Sofern die Daten für Momentanleistung und Zählerstand direkt in einem Device vorliegen, können analoge Notifys für dieses Device implementiert werden. Die Zielwerte lauten:
* Für den Momentan-Leistungswert <code>openWB/set/pv/1/W</code>
* Für den Zählerstand <code>openWB/set/pv/1/WhCounter</code>
Dabei muss beachtet werden, dass - wie bei der EVU-Schnittstelle - nur Integerwerte für die Momentanleistung übertragen werden dürfen.

==== Anbindung an Alexa ====
Der generische Smarthome-Skill "FHEMConnector" erlaubt nur die leider immer noch sehr limitierte Syntax von Amazon Alexa. Im Folgenden werden die Definitionen für die Befehle:
* ''"Alexa, schalte Überschussladen ein"''
* ''"Alexa, schalte Überschussladen aus"''
* ''"Alexa, schalte Überschussladen auf 6 (Prozent)"''
dargestellt. "Überschussladen auf 6" bedeutet dabei real den "Min+PV", also Überschussladen mit Minimalleistung von 6 Ampere. Je nach Tagesform von Amazon ist dabei das Sprechen von "Prozent" nötig, auch wenn dies natürlich sachlich falsch ist.
define openwb_ueberschuss dummy
attr openwb_ueberschuss alexaName Überschussladen
attr openwb_ueberschuss genericDeviceType light
attr openwb_ueberschuss readingList pct
attr openwb_ueberschuss setList on off pct
define openwb_ueberschuss_on notify openwb_ueberschuss:on set openwb_mqtt publish openWB/set/ChargeMode 2
define openwb_ueberschuss_off notify openwb_ueberschuss:off set openwb_mqtt publish openWB/set/ChargeMode 3
define openwb_ueberschuss_pct notify openwb_ueberschuss:pct:.* set openwb_mqtt publish openWB/config/set/pv/minCurrentMinPv $EVTPART1 ;; set openwb_mqtt publish openWB/set/ChargeMode 1

==Anwendungs Beispiele==
===Komplexe Anbindung===
[[Bild:Kia.PNG|mini|700px|rechts|WallBox mit Kia Fahrzeug]]
Hier mal ein Beispiel mit weiteren Schnittstellen in der Haussteuerung. Im Hintergrund arbeitet ein Wechselrichter Schwarm mit einem Hausspeicher, der beim BEV Laden gesperrt wird. Die openWB kommuniziert direkt mit den zwei Kostal Wechselrichtern, dem KSEM und dem am Master angeschlossenen Speicher. Das BEV ist über Kia Connect angebunden.
[[Bild:WB_1.PNG|mini|700px|rechts|openWB mit Statistiken]]
[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss, inklusive Wechselrichter, raus kommen. Die openWBs sind unten links.]]
====Verwendete Schnittstellen / Devices====
=====openWB MQTT=====
Wie oben beschrieben mit folgender MQTT definition. Im Bild ist das DOIF dargestellt und das MQTT Device als kurze Darstellung unterhalb der Tabelle. Das MQTT wird nur zur Kopplung verwendet, hat jedoch jetzt auch ein stateFormat inklusieve Statistiken erhalten.

RAW des MQTT Device
<syntaxhighlight lang="Perl">
defmod WB_1 MQTT2_DEVICE WB_1_MQTT2
attr WB_1 DbLogExclude .*
attr WB_1 DbLogInclude lp_1_.*,.*AllChargePoints.*,ChargeMode
attr WB_1 IODev WB_1_MQTT2
attr WB_1 alias WB_1
attr WB_1 autocreate 0
attr WB_1 comment Die openWB besteht aus zwei Ladepunkten.
attr WB_1 devicetopic openWB
attr WB_1 disable 0
attr WB_1 event-on-change-reading lp_1_.*,.*AllChargePoints.*,ChargeMode
attr WB_1 group PV Eigenverbrauch
attr WB_1 icon fuel
attr WB_1 readingList $DEVICETOPIC/global/WHouseConsumption:.* WHouseConsumption\
$DEVICETOPIC/global/WAllChargePoints:.* WAllChargePoints\
$DEVICETOPIC/global/ChargeMode:.* {my %h=(0=>'SofortLaden',1=>'MinPV',2=>'NurPV',3=>'Stop',4=>'Standby');; return {ChargeMode=>$h{$EVENT}}}\
\
$DEVICETOPIC/global/awattar/boolAwattarEnabled:.* boolAwattarEnabled\
$DEVICETOPIC/global/awattar/ActualPriceForCharging:.* ActualPriceForCharging\
$DEVICETOPIC/global/awattar/MaxPriceForCharging:.* MaxPriceForCharging\
$DEVICETOPIC/global/boolRse:.* boolRse\
$DEVICETOPIC/global/DailyYieldAllChargePointsKwh:.* DailyYieldAllChargePointsKwh\
$DEVICETOPIC/global/rfidConfigured:.* rfidConfigured\
$DEVICETOPIC/global/kWhCounterAllChargePoints:.* kWhCounterAllChargePoints\
$DEVICETOPIC/global/strLastmanagementActive:.* strLastmanagementActive\
$DEVICETOPIC/global/ETProvider/modulePath:.* modulePath\
$DEVICETOPIC/global/cpuTemp:.* cpuTemp\
\
$DEVICETOPIC/system/Uptime:.* Uptime\
$DEVICETOPIC/system/Date:.* Date\
$DEVICETOPIC/system/Timestamp:.* Timestamp\
$DEVICETOPIC/system/Version:.* Version\
$DEVICETOPIC/system/IpAddress:.* IpAddress\
$DEVICETOPIC/system/lastRfId:.* lastRfId\
$DEVICETOPIC/system/updateInProgress:.* updateInProgress\
$DEVICETOPIC/system/ConfiguredChargePoints:.* ConfiguredChargePoints\
$DEVICETOPIC/system/lastlivevalues:.* lastlivevalues\
$DEVICETOPIC/system/randomSleep:.* randomSleep\
$DEVICETOPIC/system/wizzardDone:.* wizzardDone\
$DEVICETOPIC/system/priceForKWh:.* priceForKWh\
$DEVICETOPIC/system/reloadDisplay:.* reloadDisplay\
\
$DEVICETOPIC/evu/ASchieflast:.* ASchieflast\
\
$DEVICETOPIC/lp/1/P%Soc:.* lp_1_Pct_Soc\
$DEVICETOPIC/lp/1/%Soc:.* lp_1_current_Soc\
$DEVICETOPIC/lp/1/\x25Soc:.* lp_1__Soc\
\
$DEVICETOPIC/lp/1/countPhasesInUse:.* lp_1_countPhasesInUse\
$DEVICETOPIC/lp/1/ChargePointEnabled:.* lp_1_ChargePointEnabled\
$DEVICETOPIC/lp/1/ChargeStatus:.* lp_1_ChargeStatus\
\
$DEVICETOPIC/lp/1/kWhDailyCharged:.* lp_1_kWhDailyCharged\
$DEVICETOPIC/lp/1/kWhCounter:.* lp_1_kWhCounter\
$DEVICETOPIC/lp/1/kWhActualCharged:.* lp_1_kWhActualCharged\
$DEVICETOPIC/lp/1/kWhChargedSincePlugged:.* lp_1_kWhChargedSincePlugged\
$DEVICETOPIC/lp/1/energyConsumptionPer100km:.* lp_1_energyConsumptionPer100km\
$DEVICETOPIC/lp/1/kmCharged:.* lp_1_kmCharged\
\
$DEVICETOPIC/lp/1/strChargePointName:.* lp_1_strChargePointName\
$DEVICETOPIC/lp/1/TimeRemaining:.* lp_1_TimeRemaining\
\
$DEVICETOPIC/lp/1/PfPhase2:.* lp_1_PfPhase2\
$DEVICETOPIC/lp/1/PfPhase3:.* lp_1_PfPhase3\
$DEVICETOPIC/lp/1/PfPhase1:.* lp_1_PfPhase1\
$DEVICETOPIC/lp/1/W:.* lp_1_W\
\
$DEVICETOPIC/lp/1/boolPlugStat:.* {my %h=(0=>'no Plug',1=>'Plugged in');; return {lp_1_PlugStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/1/boolChargeStat:.* {my %h=(0=>'not loading',1=>'loading');; return {lp_1_ChargeStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/1/AConfigured:.* lp_1_AConfigured\
\
$DEVICETOPIC/lp/1/boolChargePointConfigured:.* lp_1_boolChargePointConfigured\
$DEVICETOPIC/lp/1/boolSocConfigured:.* lp_1_boolSocConfigured\
$DEVICETOPIC/lp/1/boolDirectModeChargekWh:.* lp_1_boolDirectModeChargekWh\
$DEVICETOPIC/lp/1/boolDirectChargeModeSoc:.* lp_1_boolDirectChargeModeSoc\
$DEVICETOPIC/lp/1/boolFinishAtTimeChargeActive:.* lp_1_boolFinishAtTimeChargeActive\
$DEVICETOPIC/lp/1/boolChargeAtNight:.* lp_1_boolChargeAtNight\
$DEVICETOPIC/lp/1/boolSocManual:.* lp_1_boolSocManual\
\
$DEVICETOPIC/lp/1/AutolockStatus:.* lp_1_AutolockStatus\
$DEVICETOPIC/lp/1/AutolockConfigured:.* lp_1_AutolockConfigured\
\
$DEVICETOPIC/lp/1/lastRfId:.* lp_1_lastRfId\
$DEVICETOPIC/lp/1/pluggedladungakt:.* lp_1_pluggedladungakt\
$DEVICETOPIC/lp/1/plugStartkWh:.* lp_1_plugStartkWh\
$DEVICETOPIC/lp/1/MeterSerialNumber:.* lp_1_MeterSerialNumber\
\
\
$DEVICETOPIC/lp/2/P%Soc:.* lp_2_Pct_Soc\
$DEVICETOPIC/lp/2/%Soc:.* lp_2_current_Soc\
$DEVICETOPIC/lp/2/\x25Soc:.* lp_2__Soc\
\
$DEVICETOPIC/lp/2/countPhasesInUse:.* lp_2_countPhasesInUse\
$DEVICETOPIC/lp/2/ChargePointEnabled:.* lp_2_ChargePointEnabled\
$DEVICETOPIC/lp/2/ChargeStatus:.* lp_2_ChargeStatus\
\
$DEVICETOPIC/lp/2/kWhDailyCharged:.* lp_2_kWhDailyCharged\
$DEVICETOPIC/lp/2/kWhCounter:.* lp_2_kWhCounter\
$DEVICETOPIC/lp/2/kWhActualCharged:.* lp_2_kWhActualCharged\
$DEVICETOPIC/lp/2/kWhChargedSincePlugged:.* lp_2_kWhChargedSincePlugged\
$DEVICETOPIC/lp/2/energyConsumptionPer100km:.* lp_2_energyConsumptionPer100km\
$DEVICETOPIC/lp/2/kmCharged:.* lp_2_kmCharged\
\
$DEVICETOPIC/lp/2/strChargePointName:.* lp_2_strChargePointName\
$DEVICETOPIC/lp/2/TimeRemaining:.* lp_2_TimeRemaining\
\
$DEVICETOPIC/lp/2/W:.* lp_2_W\
\
$DEVICETOPIC/lp/2/boolPlugStat:.* {my %h=(0=>'no Plug',1=>'Plugged in');; return {lp_2_PlugStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/2/boolChargeStat:.* {my %h=(0=>'not loading',1=>'loading');; return {lp_2_ChargeStat=>$h{$EVENT}}}\
$DEVICETOPIC/lp/2/AConfigured:.* lp_2_AConfigured\
\
$DEVICETOPIC/lp/2/boolChargePointConfigured:.* lp_2_boolChargePointConfigured\
$DEVICETOPIC/lp/2/boolSocConfigured:.* lp_2_boolSocConfigured\
$DEVICETOPIC/lp/2/boolDirectModeChargekWh:.* lp_2_boolDirectModeChargekWh\
$DEVICETOPIC/lp/2/boolDirectChargeModeSoc:.* lp_2_boolDirectChargeModeSoc\
$DEVICETOPIC/lp/2/boolFinishAtTimeChargeActive:.* lp_2_boolFinishAtTimeChargeActive\
$DEVICETOPIC/lp/2/boolChargeAtNight:.* lp_2_boolChargeAtNight\
$DEVICETOPIC/lp/2/boolSocManual:.* lp_2_boolSocManual\
\
$DEVICETOPIC/lp/2/AutolockStatus:.* lp_2_AutolockStatus\
$DEVICETOPIC/lp/2/AutolockConfigured:.* lp_2_AutolockConfigured\
\
$DEVICETOPIC/lp/2/lastRfId:.* lp_2_lastRfId\
$DEVICETOPIC/lp/2/pluggedladungakt:.* lp_2_pluggedladungakt\
$DEVICETOPIC/lp/2/plugStartkWh:.* lp_2_plugStartkWh\
$DEVICETOPIC/lp/2/MeterSerialNumber:.* lp_2_MeterSerialNumber\
\
\
$DEVICETOPIC/boolChargeAtNight_direct:.* boolChargeAtNight_direct\
$DEVICETOPIC/boolChargeAtNight_nurpv:.* boolChargeAtNight_nurpv\
$DEVICETOPIC/boolChargeAtNight_minpv:.* boolChargeAtNight_minpv\
$DEVICETOPIC/boolDisplayHouseConsumption:.* boolDisplayHouseConsumption\
$DEVICETOPIC/boolDisplayDailyCharged:.* boolDisplayDailyCharged\
$DEVICETOPIC/boolEvuSmoothedActive:.* boolEvuSmoothedActive\
$DEVICETOPIC/pv/bool70PVDynActive:.* bool70PVDynActive\
$DEVICETOPIC/pv/W70PVDyn:.* W70PVDyn\
$DEVICETOPIC/pv/bool70PVDynStatus:.* bool70PVDynStatus\
$DEVICETOPIC/pv/CounterTillStartPvCharging:.* CounterTillStartPvCharging\
$DEVICETOPIC/pv/W:.* W\
$DEVICETOPIC/config/get/pv/nurpv70dynact:.* nurpv70dynact\
$DEVICETOPIC/config/get/pv/nurpv70dynw:.* nurpv70dynw\
$DEVICETOPIC/config/get/pv/priorityModeEVBattery:.* priorityModeEVBattery\
$DEVICETOPIC/config/get/pv/lp/1/minSocAlwaysToChargeTo:.* lp_1_minSocAlwaysToChargeTo\
$DEVICETOPIC/config/get/pv/lp/1/maxSoc:.* lp_1_maxSoc\
$DEVICETOPIC/config/get/pv/lp/1/minSocAlwaysToChargeToCurrent:.* lp_1_minSocAlwaysToChargeToCurrent\
$DEVICETOPIC/config/get/pv/lp/1/maxSocToChargeTo:.* lp_1_maxSocToChargeTo\
$DEVICETOPIC/config/get/pv/lp/1/minCurrent:.* lp_1_minCurrent\
$DEVICETOPIC/config/get/pv/lp/1/socLimitation:.* lp_1_socLimitation\
$DEVICETOPIC/config/get/pv/lp/2/minCurrent:.* lp_2_minCurrent\
$DEVICETOPIC/config/get/pv/lp/2/maxSoc:.* lp_2_maxSoc\
$DEVICETOPIC/config/get/pv/lp/2/socLimitation:.* lp_2_socLimitation\
$DEVICETOPIC/config/get/pv/socStopChargeAtMinPv:.* socStopChargeAtMinPv\
$DEVICETOPIC/config/get/pv/regulationPoint:.* regulationPoint\
$DEVICETOPIC/config/get/pv/minBatteryDischargeSocAtBattPriority:.* minBatteryDischargeSocAtBattPriority\
$DEVICETOPIC/config/get/pv/minBatteryChargePowerAtEvPriority:.* minBatteryChargePowerAtEvPriority\
$DEVICETOPIC/config/get/pv/minFeedinPowerBeforeStart:.* minFeedinPowerBeforeStart\
$DEVICETOPIC/config/get/pv/boolAdaptiveCharging:.* boolAdaptiveCharging\
$DEVICETOPIC/config/get/pv/adaptiveChargingFactor:.* adaptiveChargingFactor\
$DEVICETOPIC/config/get/pv/batteryDischargePowerAtBattPriority:.* batteryDischargePowerAtBattPriority\
$DEVICETOPIC/config/get/pv/boolShowPriorityIconInTheme:.* boolShowPriorityIconInTheme\
$DEVICETOPIC/config/get/pv/maxPowerConsumptionBeforeStop:.* maxPowerConsumptionBeforeStop\
$DEVICETOPIC/config/get/pv/stopDelay:.* stopDelay\
$DEVICETOPIC/config/get/pv/chargeSubmode:.* chargeSubmode\
$DEVICETOPIC/config/get/pv/minCurrentMinPv:.* minCurrentMinPv\
$DEVICETOPIC/config/get/pv/socStartChargeAtMinPv:.* socStartChargeAtMinPv\
$DEVICETOPIC/config/get/pv/startDelay:.* startDelay\
$DEVICETOPIC/config/get/sofort/lp/2/energyToCharge:.* lp_2_energyToCharge\
$DEVICETOPIC/config/get/sofort/lp/2/chargeLimitation:.* lp_2_chargeLimitation\
$DEVICETOPIC/config/get/sofort/lp/2/socToChargeTo:.* lp_2_socToChargeTo\
$DEVICETOPIC/config/get/sofort/lp/2/current:.* lp_2_current\
\
$DEVICETOPIC/config/get/sofort/lp/1/socToChargeTo:.* lp_1_socToChargeTo\
\
$DEVICETOPIC/config/get/sofort/lp/1/energyToCharge:.* lp_1_energyToCharge\
$DEVICETOPIC/config/get/sofort/lp/1/chargeLimitation:.* lp_1_chargeLimitation\
$DEVICETOPIC/config/get/sofort/lp/1/current:.* lp_1_current\
$DEVICETOPIC/config/get/global/minEVSECurrentAllowed:.* minEVSECurrentAllowed\
$DEVICETOPIC/config/get/global/maxEVSECurrentAllowed:.* maxEVSECurrentAllowed\
$DEVICETOPIC/config/get/global/dataProtectionAcknoledged:.* dataProtectionAcknoledged\
$DEVICETOPIC/config/get/global/slaveMode:.* slaveMode\
$DEVICETOPIC/config/get/u1p3p/standbyPhases:.* standbyPhases\
$DEVICETOPIC/config/get/u1p3p/sofortPhases:.* sofortPhases\
$DEVICETOPIC/config/get/u1p3p/nachtPhases:.* nachtPhases\
$DEVICETOPIC/config/get/u1p3p/minundpvPhases:.* minundpvPhases\
$DEVICETOPIC/config/get/u1p3p/nurpvPhases:.* nurpvPhases\
$DEVICETOPIC/config/get/u1p3p/isConfigured:.* isConfigured\
$DEVICETOPIC/boolChargeAtNight_standby:.* boolChargeAtNight_standby\
$DEVICETOPIC/set/system/reloadDisplay:.* reloadDisplay\
$DEVICETOPIC/set/system/topicSender:.* topicSender\
$DEVICETOPIC/set/lp/2/faultState:.* lp_2_faultState\
$DEVICETOPIC/set/lp/2/faultStr:.* lp_2_faultStr\
$DEVICETOPIC/set/lp/2/ChargePointEnabled:.* lp_2_ChargePointEnabled
attr WB_1 room MQTT2_DEVICE,Strom->Photovoltaik
attr WB_1 setList Lademodus:SofortLaden,Min+PV,NurPV,Stop,Standby { my %h=(SofortLaden=>'0','Min+PV'=>'1',NurPV=>'2',Stop=>'3',Standby=>'4');;qq($DEVICETOPIC/set/ChargeMode $h{$EVTPART1}) }\
DirectChargeSubMode:Aus,kWh_Laden,SoC_Laden { my %h=(Aus=>'0',kWh_Laden=>'1',SoC_Laden=>'2');;qq($DEVICETOPIC/set/lp1/DirectChargeSubMode $h{$EVTPART1}) }\
lp_1_socToChargeTo:50,60,70,80,90,100 { qq($DEVICETOPIC/config/set/sofort/lp/1/socToChargeTo $EVTPART1) }
attr WB_1 sortby 311
attr WB_1 stateFormat {\
my $YearBefore='LogDBRep_Statistic_previous_Year';;\
my $DUMMY = "";;\
my $date = POSIX::strftime("%Y-%m-%d",localtime(time_str2num(ReadingsTimestamp($name, "lastlivevalues",0))));;\
\
my $ChargeMode = ReadingsVal($name,"ChargeMode","n/a");;\
$ChargeMode = ($ChargeMode eq "SofortLaden")? "SofortLaden" : ($ChargeMode eq "MinPV")? "Min+PV" : ($ChargeMode eq "NurPV")? "NurPV" : $ChargeMode;;\
\
my $lp_1_Name = ReadingsVal($name,"lp_1_strChargePointName","n/a");;\
my $lp_1_Power = ReadingsVal($name,"lp_1_W",0)." W";;\
my $lp_1_Power_1 = ReadingsVal($name,"lp_1_countPhasesInUse",0)."P ".ReadingsVal($name,"lp_1_AConfigured",0)."A";;\
my $lp_1_Status_1 = ReadingsVal($name,"lp_1_PlugStat","n/a")." ".ReadingsVal($name,"lp_1_ChargeStat","n/a");;\
my $lp_1_Status_2 = ReadingsVal($name,"lp_1_TimeRemaining","n/a");;\
\
my $lp_1_Power_d = ReadingsVal($name,"lp_1_kWhDailyCharged",0)." kWh";;\
my $lp_1_Power_m = round(ReadingsVal($name,"lp_1_kWhCounter_Month",0),0)." kWh";;\
my $lp_1_Power_j = sprintf("%04d / %04d",ReadingsVal($name,"lp_1_kWhCounter_Year",0),ReadingsVal($YearBefore,"lp_1_kWhCounter_Year",0));;\
my $lp_1_Power_t = round(ReadingsVal($name,"lp_1_kWhCounter",0),0)." kWh";;\
\
my $lp_2_Name = ReadingsVal($name,"lp_2_strChargePointName","n/a");;\
my $lp_2_Power = ReadingsVal($name,"lp_2_W",0)." W";;\
my $lp_2_Power_1 = ReadingsVal($name,"lp_2_countPhasesInUse",0)."P ".ReadingsVal($name,"lp_2_AConfigured",0)."A";;\
my $lp_2_Status_1 = ReadingsVal($name,"lp_2_PlugStat","n/a")." ".ReadingsVal($name,"lp_2_ChargeStat","n/a");;\
my $lp_2_Status_2 = " ".ReadingsVal($name,"lp_2_TimeRemaining","n/a");;\
\
my $lp_2_Power_d = ReadingsVal($name,"lp_2_kWhDailyCharged",0)." kWh";;\
my $lp_2_Power_m = round(ReadingsVal($name,"lp_2_kWhCounter_Month",0),0)." kWh";;\
my $lp_2_Power_j = sprintf("%04d / %04d",ReadingsVal($name,"lp_2_kWhCounter_Year",0),ReadingsVal($YearBefore,"lp_2_kWhCounter_Year",0));;\
my $lp_2_Power_t = round(ReadingsVal($name,"lp_2_kWhCounter",0),0)." kWh";;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 52%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
<col span='1' style='width: 12%;;'>\
</colgroup>\
<tr><td style='padding-right:5px;;padding-left:5px;;font-weight:bold'>Wallbox</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>$ChargeMode</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Status</td><td style='padding-right:5px;;padding-left:5px;;text-align:center;;font-weight:bold'>Restladezeit</td><td style='padding-right:5px;;padding-left:5px;;text-align:center;;font-weight:bold'>Leistung</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_1_Name."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$DUMMY."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Status_1."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Status_2." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_1." ".$lp_1_Power."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_2_Name."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$DUMMY."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Status_1."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Status_2." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_1." ".$lp_2_Power."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;font-weight:bold'>Statistik vom $date</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>aktuell</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Heute</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Monat</td><td style='padding-right:5px;;padding-left:5px;;font-weight:bold;;text-align:center'>Jahr/Vorjahr</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_1_Name."<td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_d."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_m." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_1_Power_j."</td></tr>\
<tr><td style='padding-right:5px;;padding-left:5px;;text-align:left;;font-weight:bold'> ; ;".$lp_2_Name."<td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_d."</td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_m." </td><td style='padding-right:5px;;padding-left:5px;;text-align:center'>".$lp_2_Power_j."</td></tr>\
</table>\
</html>"\
}
attr WB_1 userReadings lp_1_kWhCounter_Month:lp_1_kWhCounter.* { round(ReadingsVal("$NAME","lp_1_kWhCounter",0) - ReadingsVal("$NAME","lp_1_kWhCounter_init_Month",0),0) },\
lp_1_kWhCounter_Year:lp_1_kWhCounter.* { round(ReadingsVal("$NAME","lp_1_kWhCounter",0) - ReadingsVal("$NAME","lp_1_kWhCounter_init_Year",0),0) },\
\
lp_2_kWhCounter_Month:lp_2_kWhCounter.* { round(ReadingsVal("$NAME","lp_2_kWhCounter",0) - ReadingsVal("$NAME","lp_2_kWhCounter_init_Month",0),0) },\
lp_2_kWhCounter_Year:lp_2_kWhCounter.* { round(ReadingsVal("$NAME","lp_2_kWhCounter",0) - ReadingsVal("$NAME","lp_2_kWhCounter_init_Year",0),0) }
</syntaxhighlight>

=====Kia connect MQTT=====
Das Kia_connect Device empfängt und sendet die MQTT Nachrichten zum Node-red Flow für das Kia BEV.

RAW des Kia connect
<syntaxhighlight lang="Perl">
defmod Kia_connect MQTT2_DEVICE
attr Kia_connect DbLogExclude .*
attr Kia_connect DbLogInclude .*
attr Kia_connect IODev MQTT2_FHEM_Server
attr Kia_connect alias Kia_connect
attr Kia_connect autocreate 1
attr Kia_connect devicetopic bluelinky
attr Kia_connect group PV Eigenverbrauch-Steuerung
attr Kia_connect icon car
attr Kia_connect readingList $DEVICETOPIC/status:.* { json2nameValue($EVENT) }\
$DEVICETOPIC/location.* { json2nameValue($EVENT) }\
$DEVICETOPIC/odometer:.* { json2nameValue($EVENT) }\
$DEVICETOPIC/req_received:.* req_received\
$DEVICETOPIC/req_active:.* req_active
attr Kia_connect room MQTT2_DEVICE,Strom->Photovoltaik
attr Kia_connect setList getOdometer req/$DEVICETOPIC/get_odometer get_odometer\
getStatus req/$DEVICETOPIC/get_status get_status\
getLocation req/$DEVICETOPIC/get_location get_location\
getTripinfo req/$DEVICETOPIC/get_tripinfo\
getAll req/$DEVICETOPIC/get_all get_all\
setChargeTargetSoc req/$DEVICETOPIC/set_chargetargets\
startCharge req/$DEVICETOPIC/start_charging start_charging\
stopCharge req/$DEVICETOPIC/stop_charging stop_charging\
stopClimate req/$DEVICETOPIC/stop_climate stop_climate\
startClimate req/$DEVICETOPIC/start_climate
attr Kia_connect sortby 402
attr Kia_connect stateFormat req_active
attr Kia_connect userReadings atHomeStanding:location.* { ((abs(AttrVal("global","latitude",49.85) - ReadingsVal($NAME,"location_coord_lat",0)) <= 0.001) && (abs(AttrVal("global","longitude",8.49) - ReadingsVal($NAME,"location_coord_lon",0)) <= 0.001) && (ReadingsVal($NAME,"location_speed_value",1) == 0)) ? 'true' : 'false';;;; },\
batSOC:status.* { ReadingsVal($NAME,"status_evStatus_batteryStatus",0);;;;},\
connected:status.* { (ReadingsVal($NAME,"status_evStatus_batteryPlugin",0) != 0) ? 'true' : 'false';;;;},\
charging:status.* { ReadingsVal($NAME,"status_evStatus_batteryCharge",'false');;;;},\
targetSOC:status.* { ReadingsVal($NAME,"status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel",0);;;;},\
time2targetSOC:status.* { my $t = ReadingsVal($NAME,"status_evStatus_remainTime2_atc_value",1);;;; sprintf("%02d:%02d", $t/60%60, $t%60);;},\
range:status.* { ReadingsVal($NAME,"status_evStatus_drvDistance_1_rangeByFuel_totalAvailableRange_value",0);;;;},\
bat12v:status.* { ReadingsVal($NAME,"status_battery_batSoc",0);;;;}
</syntaxhighlight>

=====Node-red=====
[[Bild:Kia Flow.PNG|mini|900px|rechts|Node-red Kia Flow]]
Node-red habe ich einfach in einem Docker Container runter geladen und gestartet. Über Port 1880 kommt man direkt in die GUI und kann den ersten Flow laden.

docker-compose .yml Eintrag
<syntaxhighlight lang="Perl">
node-red:
image: nodered/node-red:latest
restart: always
environment:
- TZ=Europe/Berlin
ports:
- 1880:1880
volumes:
- ./node-red/data:/data
</syntaxhighlight>

Danach fehlt im Container noch folgende Erweiterung für den Node-red Flow
<syntaxhighlight lang="Perl">
npm install node-red-contrib-bluelinky
</syntaxhighlight>

=====Kia Connect=====
<pre>
Kia connect ist eine API für Kia und Hyundai E-Autos mit der man Daten vom Auto abfragen kann und auch einige Steuerungen möglich sind.
Mit Node-red und BlueLinky wird die Schnittstelle bedient.
Der Flow ist nicht ursprünglich von mir, wurde jedoch noch erweitert.
Vor dem Laden des Flows sind noch die persönlichen Verbindungsdaten im JSON einzutragen.

Nach dem Laden ist ein Test mit den Inject Symbolen und der Debug Funktionalität möglich und auch sinnvoll.
Unterhalb der MQTT - und BlueLinky Symbole sollte "Verbunden" oder "Ready" erscheinen.
</pre>
'''Wichtig beim Kia ist, dass für das Laden über die openWB als SOC Ziel 80% im standard Modus konfiguriert wird.''' Ansonsten wundert man sich warum das Laden einfach nicht starten möchte. Im Default ist dort bei mir nur 50% eingetragen gewesen :-). Mit jetzt 100% kann die openWB auch selber einen Ziel SOC bestimmen, ansonsten hört das BEV einfach selber auf zu laden.

Weiterhin sollte man darauf achten, dass man nur eine begrenzte Anzahl von Nachrichten mit dem Kia BEV pro Tag austauschen kann. Das wurde im DOIF schon etwas berücksichtigt (1x pro Stunde), kann jedoch bei gleichzeitiger Verwendung der Handy App oder der SOC Abfrage im openWB Kia Modul auch mal zu Fehlern führen. Durch die Stündliche Status Abfrage im DOIF kommt es natürlich zu Verzögerungen im FHEM Status. Dann einfach einmal Manuell abfragen.

Node-red JSON Import
<syntaxhighlight lang="json">
[ {
"id": "866c75dd.edd9a8",
"type": "tab",
"label": "Kia e-Niro",
"disabled": false,
"info": ""
},
{
"id": "bb13a99d.68b8f8",
"type": "mqtt-broker",
"name": "mqtt_Server",
"broker": "<FHEM MQTT IP Adresse>",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"compatmode": false,
"protocolVersion": "4",
"keepalive": "60",
"cleansession": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"sessionExpiry": ""
},
{
"id": "452a3304.58c8fc",
"type": "bluelinky",
"username": "<Mail Adresse bei Kia>",
"password": "<Passwort>",
"region": "EU",
"pin": "<Pin>",
"vin": "<VIN>",
"brand": "kia"
},
{
"id": "91a345fa.5757a8",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_status",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 260,
"y": 280,
"wires": [
[
"15dfb508.c6497b",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "5ad085b9.05739c",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/start_climate",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 680,
"wires": [
[
"b27d74de.38c808",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "15dfb508.c6497b",
"type": "car-status",
"z": "866c75dd.edd9a8",
"name": "Get status",
"dorefresh": true,
"parsed": false,
"bluelinky": "452a3304.58c8fc",
"x": 1110,
"y": 280,
"wires": [
[
"cccc9476.d56dd8",
"226ed925.607bb6"
]
]
},
{
"id": "87abdd88.8ff4d",
"type": "car-odometer",
"z": "866c75dd.edd9a8",
"name": "Get car odometer",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 200,
"wires": [
[
"40d2361c.579588",
"226ed925.607bb6"
]
]
},
{
"id": "31100f9a.40008",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "locationWrapper",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"location\": msg.payload,\n \"error\": false\n };\n \n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 1490,
"y": 120,
"wires": [
[
"85a07155.a0f9f",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "bea1d927.0f3908",
"type": "car-location",
"z": "866c75dd.edd9a8",
"name": "Get car location",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 120,
"wires": [
[
"31100f9a.40008",
"226ed925.607bb6"
]
]
},
{
"id": "3c949d67.0d83b2",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_location",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 120,
"wires": [
[
"bea1d927.0f3908",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "cccc9476.d56dd8",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "analyseStatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n let status = msg.payload;\n status.airTemp.value = 14+(parseInt(status.airTemp.value,16)/2);\n try{\n status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n } catch(e) {}\n\n let time = status.evStatus.remainTime2.atc.value/60;\n let result = { \n \"batSOC\": status.evStatus.batteryStatus,\n \"connected\": (status.evStatus.batteryPlugin !== 0),\n \"charging\": status.evStatus.batteryCharge,\n \"targetSOC\": status.evStatus.reservChargeInfos.targetSOClist[1].targetSOClevel,\n \"time2targetSOC\": (Math.floor(time) + \":\" + (\"0\" + Math.floor((time % 1)*60)).slice(-2)), // h:mm\n \"range\": status.evStatus.drvDistance[0].rangeByFuel.totalAvailableRange.value,\n \"bat12v\": status.battery.batSoc\n };\n \n //msg.payload = result;\n msg.payload = {\n \"status\": status,\n \"error\": false\n \n };\n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1480,
"y": 280,
"wires": [
[
"3efceea0.c81b12",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "85a07155.a0f9f",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/location",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1910,
"y": 120,
"wires": []
},
{
"id": "3efceea0.c81b12",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/status",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1900,
"y": 280,
"wires": []
},
{
"id": "327104fc.71e1bc",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/odometer",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 1910,
"y": 200,
"wires": []
},
{
"id": "844a32f4.2e029",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/stop_climate",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 270,
"y": 760,
"wires": [
[
"7d3ae860.d8c9a8",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "57d91e50.7e96",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/start_charging",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 280,
"y": 820,
"wires": [
[
"6eebc52c.ee23dc",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "6029f0a0.b73e",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/stop_charging",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 280,
"y": 880,
"wires": [
[
"84a1ae.74912e5",
"33b1bc85.662694",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "c5ecf76c.e753c8",
"type": "start-car",
"z": "866c75dd.edd9a8",
"name": "Start car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 680,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "6eebc52c.ee23dc",
"type": "start-charge",
"z": "866c75dd.edd9a8",
"name": "Start Charging",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 820,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "84a1ae.74912e5",
"type": "stop-charge",
"z": "866c75dd.edd9a8",
"name": "Stop Charging",
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 880,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "7d3ae860.d8c9a8",
"type": "stop-car",
"z": "866c75dd.edd9a8",
"name": "Stop car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 760,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "b27d74de.38c808",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "obj",
"pretty": false,
"x": 750,
"y": 680,
"wires": [
[
"c5ecf76c.e753c8",
"33b1bc85.662694"
]
]
},
{
"id": "45a6a8e6.2abfd8",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_odometer",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 280,
"y": 200,
"wires": [
[
"87abdd88.8ff4d",
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2"
]
]
},
{
"id": "33b1bc85.662694",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 930,
"y": 920,
"wires": []
},
{
"id": "ce62ba4f.d86548",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/req_received",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 860,
"y": 480,
"wires": []
},
{
"id": "1babee6c.1c2982",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_all",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"inputs": 0,
"x": 250,
"y": 360,
"wires": [
[
"ce62ba4f.d86548",
"3f82a275.5a0b6e",
"24d5e0b.3aafc2",
"4375fbb9.00fb44"
]
]
},
{
"id": "262df5dc.57916a",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1850,
"y": 80,
"wires": []
},
{
"id": "811aa567.e89f98",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1470,
"y": 1040,
"wires": []
},
{
"id": "3f82a275.5a0b6e",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 930,
"y": 80,
"wires": []
},
{
"id": "24d5e0b.3aafc2",
"type": "change",
"z": "866c75dd.edd9a8",
"name": "",
"rules": [
{
"t": "set",
"p": "payload",
"pt": "msg",
"to": "pending",
"tot": "str"
}
],
"action": "",
"property": "",
"from": "",
"to": "",
"reg": false,
"x": 790,
"y": 1140,
"wires": [
[
"4dd1ea4a.52f144",
"fecad185.324f8"
]
]
},
{
"id": "f487d6d6.a4d568",
"type": "change",
"z": "866c75dd.edd9a8",
"name": "",
"rules": [
{
"t": "set",
"p": "payload",
"pt": "msg",
"to": "idle",
"tot": "str"
}
],
"action": "",
"property": "",
"from": "",
"to": "",
"reg": false,
"x": 1910,
"y": 760,
"wires": [
[
"4dd1ea4a.52f144",
"fecad185.324f8"
]
]
},
{
"id": "4dd1ea4a.52f144",
"type": "mqtt out",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "bluelinky/req_active",
"qos": "",
"retain": "",
"broker": "bb13a99d.68b8f8",
"x": 2140,
"y": 1100,
"wires": []
},
{
"id": "fecad185.324f8",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "false",
"statusVal": "",
"statusType": "auto",
"x": 2110,
"y": 1160,
"wires": []
},
{
"id": "40d2361c.579588",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "odometerWrapper",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n msg.payload = { \n \"odometer\": msg.payload,\n \"error\": false\n };\n\n return msg;\n}",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 1490,
"y": 200,
"wires": [
[
"327104fc.71e1bc",
"262df5dc.57916a",
"f487d6d6.a4d568"
]
]
},
{
"id": "226ed925.607bb6",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1430,
"y": 80,
"wires": []
},
{
"id": "4375fbb9.00fb44",
"type": "car-fullstatus",
"z": "866c75dd.edd9a8",
"name": "Get full status",
"dorefresh": true,
"bluelinky": "452a3304.58c8fc",
"x": 1120,
"y": 360,
"wires": [
[
"226ed925.607bb6",
"69b6c4df.ea6bcc",
"89681a97.9e24d8",
"92dc3ff4.1d6e3"
]
]
},
{
"id": "69b6c4df.ea6bcc",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "locationFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"location\": msg.payload.vehicleLocation,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1500,
"y": 360,
"wires": [
[
"85a07155.a0f9f",
"331e5860.907808"
]
]
},
{
"id": "92dc3ff4.1d6e3",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "statusFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n let status = msg.payload.vehicleStatus;\n try{\n status.airTemp.value = 14+(parseInt(status.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reservChargeInfo.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value = 14+(parseInt(status.evStatus.reservChargeInfos.reserveChargeInfo2.reservChargeInfoDetail.reservFatcSet.airTemp.value,16)/2);\n } catch(e) {}\n\n msg.payload = { \n \"status\": status,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1500,
"y": 480,
"wires": [
[
"3efceea0.c81b12",
"f487d6d6.a4d568",
"331e5860.907808"
]
]
},
{
"id": "89681a97.9e24d8",
"type": "function",
"z": "866c75dd.edd9a8",
"name": "odometerFromFullstatus",
"func": "if(msg.payload.hasOwnProperty(\"body\")) {\n msg.payload = {\"error\":true};\n return msg;\n}\nelse {\n\n msg.payload = { \n \"odometer\": msg.payload.odometer,\n \"error\": false\n };\n \n return msg;\n}\n",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"x": 1510,
"y": 420,
"wires": [
[
"327104fc.71e1bc",
"331e5860.907808"
]
]
},
{
"id": "331e5860.907808",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1850,
"y": 520,
"wires": []
},
{
"id": "aa4d220b.f7e19",
"type": "set-chargetargets",
"z": "866c75dd.edd9a8",
"name": "Set charge targets",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 960,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "4c03338d.2f15ec",
"type": "login",
"z": "866c75dd.edd9a8",
"name": "Login",
"bluelinky": "452a3304.58c8fc",
"x": 1090,
"y": 1040,
"wires": [
[
"811aa567.e89f98"
]
]
},
{
"id": "28b868f5.16cb48",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "43200",
"crontab": "",
"once": true,
"onceDelay": "12",
"topic": "",
"payloadType": "date",
"x": 950,
"y": 1040,
"wires": [
[
"4c03338d.2f15ec"
]
]
},
{
"id": "db9ecdb5.a9683",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/set_chargetargets",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 290,
"y": 960,
"wires": [
[
"7064a8d53256b646",
"ce62ba4f.d86548",
"24d5e0b.3aafc2"
]
]
},
{
"id": "44155ad70c47b0dd",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 260,
"wires": [
[
"15dfb508.c6497b"
]
]
},
{
"id": "7064a8d53256b646",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "obj",
"pretty": false,
"x": 750,
"y": 960,
"wires": [
[
"33b1bc85.662694",
"aa4d220b.f7e19"
]
]
},
{
"id": "7064395e56292844",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 340,
"wires": [
[
"4375fbb9.00fb44"
]
]
},
{
"id": "5f9ff828080f5fe6",
"type": "lock-car",
"z": "866c75dd.edd9a8",
"name": "Lock car",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 560,
"wires": [
[
"811aa567.e89f98",
"f487d6d6.a4d568"
]
]
},
{
"id": "492f5b94a865e47b",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 540,
"wires": [
[
"5f9ff828080f5fe6"
]
]
},
{
"id": "d6f3f148e765caf9",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/car_lock",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 260,
"y": 560,
"wires": [
[
"5f9ff828080f5fe6",
"ce62ba4f.d86548"
]
]
},
{
"id": "cdc13a486db22b8e",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/car_unlock",
"qos": "0",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": false,
"inputs": 0,
"x": 270,
"y": 620,
"wires": [
[
"99f5c3a41ac3e754",
"ce62ba4f.d86548"
]
]
},
{
"id": "99f5c3a41ac3e754",
"type": "unlock-car",
"z": "866c75dd.edd9a8",
"name": "Unlock car",
"bluelinky": "452a3304.58c8fc",
"x": 1110,
"y": 620,
"wires": [
[
"f487d6d6.a4d568",
"811aa567.e89f98"
]
]
},
{
"id": "ab557a0ea621403a",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 600,
"wires": [
[
"99f5c3a41ac3e754"
]
]
},
{
"id": "a525de86e4374518",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 740,
"wires": [
[
"7d3ae860.d8c9a8"
]
]
},
{
"id": "0b8cb92c042fe140",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 800,
"wires": [
[
"6eebc52c.ee23dc"
]
]
},
{
"id": "ae4c2139b08aaa28",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 860,
"wires": [
[
"84a1ae.74912e5"
]
]
},
{
"id": "dd23108ce63f456d",
"type": "get-monthlyreport",
"z": "866c75dd.edd9a8",
"name": "Get monthly report",
"bluelinky": "452a3304.58c8fc",
"x": 1130,
"y": 1280,
"wires": [
[
"e57eb97531129426"
]
]
},
{
"id": "a6e5e8deb52145f1",
"type": "inject",
"z": "866c75dd.edd9a8",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "",
"payloadType": "date",
"x": 940,
"y": 1260,
"wires": [
[
"dd23108ce63f456d"
]
]
},
{
"id": "95f1b6f32aafd65b",
"type": "get-tripinfo",
"z": "866c75dd.edd9a8",
"name": "Tripinfo",
"bluelinky": "452a3304.58c8fc",
"x": 1100,
"y": 1220,
"wires": [
[
"e57eb97531129426"
]
]
},
{
"id": "fb2b99958bc48593",
"type": "json",
"z": "866c75dd.edd9a8",
"name": "",
"property": "payload",
"action": "",
"pretty": false,
"x": 750,
"y": 1220,
"wires": [
[
"95f1b6f32aafd65b"
]
]
},
{
"id": "5230ebe391325b17",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_tripinfo",
"qos": "2",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 270,
"y": 1220,
"wires": [
[
"fb2b99958bc48593"
]
]
},
{
"id": "e57eb97531129426",
"type": "debug",
"z": "866c75dd.edd9a8",
"name": "",
"active": false,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 1470,
"y": 1220,
"wires": []
},
{
"id": "4fdf3b1b7811c89f",
"type": "mqtt in",
"z": "866c75dd.edd9a8",
"name": "",
"topic": "req/bluelinky/get_tripinfo",
"qos": "2",
"datatype": "auto",
"broker": "bb13a99d.68b8f8",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 270,
"y": 1280,
"wires": [
[
"dd23108ce63f456d"
]
]
}
]
</syntaxhighlight>

=====Kia_eNiro_PV DOIF mit uiTable=====
Mit diesem DOIF Device werden folgende Funktionalitäten abgebildet:
Nun dann noch das DOIF mit dem uiTable für die Status Anzeige und die Steuerung über Pull Down Menüs.

- Status Abfrage
Status jede Stunde zwischen 6 und 23 Uhr (12V min 40%)
Status beim Laden alle 15 Minuten (12V min 40%)
Anzeige des Kilometerzählers
Status des Fahrzeuges zu Hause / unterwegs und beim Laden
Fahrzeug Auf/Zu

- Klimatisierung über das Pull Down Menü
unterschiedliche Temperaturen für Heizen und Kühlen
Aktuelle Temperatur
Heizen/Klima Ein/Aus
Timer für zeitgesteuertes Klimatisieren für den Resttag oder den Nächsten Tag (vor der aktuellen Zeit)
Klimatisierung über "Abfall" Kalender (es geht nur ein Termin pro Tag, dafür aber komfortabel über das Handy)

- Komfort
Reifen Überwachung
Türen / Motorhaube / Kofferraum Überwachung
12V Batterie anzeige, wenn der Ladezustand kleiner 40% ist erfolgt keine weitere Status Abfrage

- ACCU Steuerung
Setzen des Ziel SOC beim Standard Laden
Start/Stop Laden
Accu Stand und berechnete Restkilometer

- Für openWB integratin im uiTable
Wählen des Lademodus
Vorrang EV oder Bat
Sperren des Hausspeichers entweder manuell oder automatisch beim Laden. Der vorherige Zustand wird gespeichert
Die Freigabe erfolgt über die Wechselrichter Implementierung, siehe dort [[Kostal_Plenticore_10_Plus#Externe_Speichersteuerung_.28ExternControl.29|"Externe Speicher Steuerung"]]
Geschätzte Ladezeit
Status Ladepunkt (Plug und Laden)
Lade Status Phasen und Leistung

'''Achtung, die Kia connect Abfragen sind auf ca. 200 pro Tag von Kia limitiert! Durch die Stündliche Status Abfrage im DOIF kommt es natürlich zu Verzögerungen im FHEM Status. Dann einfach einmal manuell abfragen.'''

Die Kommunikation zum Kia BEV ist manchmal sehr träge, z.B. kann eine Status Abfrage auch mal 3 Minuten dauern, deshalb wurde eine Verriegelung implementiert. Es wird ein Status pending/idle angezeigt. Nur wenn der Zustand "idel" ist, können weitere Abfragen gestartet werden. Läuft z.B. die Status Abfrage kann man ein weiteres Kommando anstarten, es wird jedoch erst abgesetzt, wenn das vorherige Kommando fertig ist. Solange bleibt im Pull Down Menü das neue Kommando stehen.

RAW des DOIF
<syntaxhighlight lang="Perl">
defmod Kia_eNiro_PV DOIF ################################################################################################################\
## 1 Kia Connect Status Abfrage erfolgt mit MQTT2 ==> node-ret ==> Kia Connect\
##\
1_Status_getAll\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( ([+00:15] and ## alle 15 Minuten\
[Kia_connect:atHomeStanding] eq "true" and ## wenn das Auto zuhause ist\
[Kia_connect:charging] eq "true" or ## und es geladen wird\
[:58] and [05:00-23:00] ## ansonsten nur jede Stunde\
) and [Kia_connect:bat12v] > 40 ## aber die 12V Batterie sollte noch genügend Ladung haben\
or [$SELF:cmd_event] eq "set_cmd_1" ## Das reagiert auf den Aufruf mit "set <Device> cmd_*"\
or [$SELF:ui_command_1] eq "Status_getAll" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "Status_getAll" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_before_1",[$SELF:ui_command_1]);;\
}\
\
fhem_set("Kia_connect getAll");; ## beliebige Kommandos für diesen Block\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
2_Klima\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_2] eq "stopClimate" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_2] eq "startHeating"\
or [$SELF:ui_command_2] eq "startCooling"\
)\
) {\
set_Reading("ui_command_before_2",[$SELF:ui_command_2]);;\
\
if ([$SELF:ui_command_2] eq "startHeating") {\
my $airTemp_value= [Kia_connect:status_airTemp_value_target_Winter];;\
fhem_set('Kia_connect startClimate {"defrost": true, "windscreenHeating": true, "temperature": '.$airTemp_value.' , "unit": "C"}');;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : startHeating"};;\
}\
if ([$SELF:ui_command_2] eq "startCooling") {\
my $airTemp_value = [Kia_connect:status_airTemp_value_target_Summer];;\
fhem_set('Kia_connect startClimate {"defrost": false, "windscreenHeating": false, "temperature": '.$airTemp_value.' , "unit": "C"}');;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : startCooling"};;\
}\
if ([$SELF:ui_command_2] eq "stopClimate") {\
fhem_set("Kia_connect ".[$SELF:ui_command_2]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 2_Klima : stopClimate"};;\
}\
fhem_set("Abfall update");;\
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
3_Laden\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_3] eq "setChargeTargetSoc" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_3] eq "startCharge"\
or [$SELF:ui_command_3] eq "stopCharge"\
)\
) {\
set_Reading("ui_command_before_3",[$SELF:ui_command_3]);;\
\
if ([$SELF:ui_command_3] eq "setChargeTargetSoc") {\
my $targetSOClist_1_targetSOClevel = [Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_1_targetSOClevel_target];;\
my $targetSOClist_2_targetSOClevel = [Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel_target];;\
fhem_set("Kia_connect setChargeTargetSoc {\"fast\": ".$targetSOClist_1_targetSOClevel.", \"slow\": ".$targetSOClist_2_targetSOClevel."}");;\
} else {\
fhem_set("Kia_connect ".[$SELF:ui_command_3]);; ## beliebige Kommandos für diesen Block\
}\
\
set_Reading("ui_command_3","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
4_Klima_timer_heizen\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [[Abfall_Abfuhr:Kiaheizen_connect_time]] ## Prüfe den Kalender Eintrag\
and [Abfall_Abfuhr:Kiaheizen_connect_date] eq $ymd ## ist es heute?\
)\
or\
( [$SELF:ui_timer_mode] eq "heizen" ## Timer zum Heizen aktiv?\
and [[$SELF:ui_timer_Start]] ## ist es soweit?\
)\
)\
) {\
\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 4_Klima_timer : startHeating"};;\
set_Reading("ui_timer_mode","Aus");; ## Schalte die Timer Funktion ab\
set_Reading("ui_command_2","startHeating");; ## Es soll geheizt werden\
fhem_set("$SELF 2_Klima");; ## Aktiviere das Heizen\
\
}\
}\
\
5_Klima_timer_kuehlen\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [[Abfall_Abfuhr:Kiakuehlen_connect_time]] ## Prüfe den Kalender Eintrag\
and [Abfall_Abfuhr:Kiakuehlen_connect_date] eq $ymd ## ist es heute?\
)\
or\
( [$SELF:ui_timer_mode] eq "kuehlen" ## Timer zum Kühler aktiv?\
and [[$SELF:ui_timer_Start]] ## ist es soweit?\
)\
)\
) {\
\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 4_Klima_timer : startCooling"};;\
set_Reading("ui_timer_mode","Aus");; ## Schalte die Timer Funktion ab\
set_Reading("ui_command_2","startCooling");; ## Es soll gekühlt werden\
fhem_set("$SELF 2_Klima");; ## Aktiviere das Kühlen\
\
}\
}\
\
6_Auf_Zu\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and [Kia_connect:req_active] eq "idle"\
and\
( [$SELF:ui_command_2] eq "car_lock" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_2] eq "car_unlock"\
)\
) {\
set_Reading("ui_command_before_2",[$SELF:ui_command_2]);;\
\
fhem_set("Kia_connect ".[$SELF:ui_command_2]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 6_Auf_Zu : ".[$SELF:ui_command_2]};;\
\
set_Reading("ui_command_2","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
7_WB_1_lp_1\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:ui_command_4] eq "SofortLaden" ## Hier wird das uiTable select ausgewertet\
or [$SELF:ui_command_4] eq "Min+PV"\
or [$SELF:ui_command_4] eq "NurPV"\
or [$SELF:ui_command_4] eq "Stop"\
or [$SELF:ui_command_4] eq "Standby"\
or [$SELF:ui_command_4] eq "Vorrang_EV"\
or [$SELF:ui_command_4] eq "Vorrang_Bat"\
)\
) {\
set_Reading("ui_command_before_4",[$SELF:ui_command_4]);;\
\
if ([$SELF:ui_command_4] eq "Vorrang_Bat" or [$SELF:ui_command_4] eq "Vorrang_EV") {\
if ([$SELF:ui_command_4] eq "Vorrang_EV") {\
fhem_set("WB_1 priorityModeEVBattery 1");;\
} else {\
fhem_set("WB_1 priorityModeEVBattery 0");;\
}\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 7_WB_1_lp_1 : ".[$SELF:ui_command_4]};;\
} else {\
fhem_set("WB_1 Lademodus ".[$SELF:ui_command_4]);;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 7_WB_1_lp_1 : Lademodus ".[$SELF:ui_command_4]};;\
}\
\
set_Reading("ui_command_4","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
8_Speicher_sperren\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:ui_command_4] eq "Hausspeicher_Sperren" ## Hier wird das uiTable select ausgewertet\
or [WB_1:lp_1_ChargeStat] eq "loading" and\
[WB_1:lp_1_PlugStat] eq "Plugged in"\
)\
) {\
set_Reading("ui_command_before_4",[$SELF:ui_command_4]);;\
\
if([$SELF:WR_1_Speicher_1_ExternControl_smart_laden_before] eq "---") {\
\
if([$SELF:SpeicherExternTrigger] eq "gesperrt" and\
[WR_1_API:Battery_InternControl_MinHomeConsumption] eq "30000" ) {\
set_Reading("WR_1_Speicher_1_ExternControl_smart_laden_before","aktiv");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_laden_before aktiv"};;\
} else {\
set_Reading("WR_1_Speicher_1_ExternControl_smart_laden_before","inaktiv");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_laden_before inaktiv"};;\
}\
\
fhem_set("WR_1_Speicher_1_ExternControl cmd_2");;\
if (AttrVal("$SELF","verbose",0) >= 0)\
{Log 3, "$SELF 8_Speicher_sperren : smart_Laden startet"};;\
}\
\
set_Reading("ui_command_4","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
9_WB_1_Zaehler_Statistiken\
{if( !([$SELF:state] eq "off") and ## DOIF enabled\
[00:01]\
) {\
fhem("setreading WB_1 lp_1_kWhCounter_init_Day ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Day ".[WB_1:lp_2_kWhCounter]);;\
\
if ($mday eq 1)\
{\
fhem("setreading WB_1 lp_1_kWhCounter_init_Month ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Month ".[WB_1:lp_2_kWhCounter]);;\
\
if ($yday eq 0)\
{\
fhem("setreading WB_1 lp_1_kWhCounter_init_Year ".[WB_1:lp_1_kWhCounter]);;\
fhem("setreading WB_1 lp_2_kWhCounter_init_Year ".[WB_1:lp_2_kWhCounter]);;\
}\
}\
}\
}
attr Kia_eNiro_PV DbLogExclude .*
attr Kia_eNiro_PV disable 0
attr Kia_eNiro_PV group PV Eigenverbrauch-Steuerung
attr Kia_eNiro_PV icon car
attr Kia_eNiro_PV room Strom->Photovoltaik
attr Kia_eNiro_PV sortby 401
attr Kia_eNiro_PV uiTable {\
package ui_Table;;\
## $TR{0} = "style='color:yellow;;text-align:left;;font-weight:bold;;font-size:18px'";; ## Reihe 0 für Überschrift\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_batt {\
my($val)=@_;;\
my $ret="position:absolute;;left:".(90*$val/100)."px;;width:90px;;height:20px;;background:linear-gradient( to right,#F8F8E0 ".(90-(90*$val/100))."px,rgba(0,0,0,0) ".(90-(90*$val/100))."px);;";;\
return $ret;;\
}\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
sub FUNC_Status_Laden {\
my($car)=@_;;\
my $charge = (::ReadingsVal($car,"charging","false") eq "true");;\
my $athome = (::ReadingsVal($car,"atHomeStanding","false") eq "true");;\
my $chargeathome = ($charge && $athome);;\
my $connectedathome = ($athome && ::ReadingsVal($car,"connected","false") eq "true");;\
\
my $ret = ($chargeathome ? "lädt zu Hause" : ($connectedathome ? "angeschlossen zu Hause" : ($athome ? "zu Hause" : ($charge ? "Lädt auswärts" : "unterwegs"))));;\
return $ret;;\
}\
sub FUNC_tire {\
my($car)=@_;;\
my $ret = 'Reifendruck okay';;\
\
if (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampAll","1") != 0) {\
my $VL = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampFL","1") eq "0")?0:1;;\
my $HL = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampRL","1") eq "0")?0:1;;\
my $VR = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampFR","1") eq "0")?0:1;;\
my $HR = (::ReadingsVal($car,"status_tirePressureLamp_tirePressureLampRR","1") eq "0")?0:1;;\
$ret = 'Reifen Störung ';;\
if ($VL == 1){$ret.=' /VL'};;\
if ($VR == 1){$ret.=' /VR'};;\
if ($HL == 1){$ret.=' /HL'};;\
if ($HR == 1){$ret.=' /HR'};;\
$ret = $ret.'';;\
}\
return $ret;;\
}\
sub FUNC_door {\
my($car)=@_;;\
my $ret = 'Türen okay ';;\
\
if (::ReadingsVal($car,"status_doorLock","false") ne "true") {\
my $VL = (::ReadingsVal($car,"status_doorOpen_frontLeft",1) == 0)?0:1;;\
my $HL = (::ReadingsVal($car,"status_doorOpen_backLeft",1) == 0)?0:1;;\
my $VR = (::ReadingsVal($car,"status_doorOpen_frontRight",1) == 0)?0:1;;\
my $HR = (::ReadingsVal($car,"status_doorOpen_backRight",1) == 0)?0:1;;\
$ret = 'Tür offen ';;\
if ($VL == 1){$ret.=' /VL'};;\
if ($VR == 1){$ret.=' /VR'};;\
if ($HL == 1){$ret.=' /HL'};;\
if ($HR == 1){$ret.=' /HR'};;\
$ret = $ret.'';;\
}\
if (::ReadingsVal($car,"status_trunkOpen","true") eq "true") {\
$ret.=' Kofferraum offen';;\
}\
if (::ReadingsVal($car,"status_hoodOpen","true") eq "true") {\
$ret.=' Motorhaube offen';;\
}\
return $ret;;\
}\
}\
\
"$SELF"|"Kommando ".::ReadingsTimestamp("Kia_connect","status_time","")."<dd>Auswahl / Kommunikation / Tacho / Info Status</dd>" | widget([$SELF:ui_command_1],"uzsuDropDown,---,Status_getAll,car_lock,car_unlock")|(([Kia_connect:req_active] eq "idle")?'idle' : ''.[Kia_connect:req_active].'') |::round([Kia_connect:odometer_value],0)." km"|FUNC_Status_Laden("Kia_connect")\
\
|"Accu<dd>Steuerung / Target Soc / Accu Status</dd>" |widget([$SELF:ui_command_3],"uzsuDropDown,---,setChargeTargetSoc,stopCharge,startCharge")|"Target SOC".widget([Kia_connect:status_evStatus_reservChargeInfos_targetSOClist_2_targetSOClevel_target],"selectnumbers,50,10,100,0,lin")." %"|""| FUNC_Status([Kia_connect:range],150,"red",[Kia_connect:range],"orange",[Kia_connect:range],250,"green",[Kia_connect:range])." km"."<div style='border-width:2px;;border-style:solid;;border-color:gray;;position:relative;;width:90px;;height:20px;;background:linear-gradient( to right, red 0px,yellow 30px,green 50px);;'>".STY(" ",FUNC_batt([Kia_connect:batSOC])).STY(::round([Kia_connect:batSOC],0)."%","font-size:16px;;position:absolute;;top:2px;;left:30px")."</div>"\
\
|"Komfort<dd>Timer / Klima / Reifen / Türen / Accu Status 12V</dd>" |widget([$SELF:ui_timer_mode],"uzsuDropDown,Aus,heizen,kuehlen").widget([$SELF:ui_timer_Start],"time")|\
((::ReadingsVal("Abfall_Abfuhr","Kiaheizen_days",0) != 0)?"Klimatisierung ".[Abfall_Abfuhr:Kiaheizen_connect_date]." ".[Abfall_Abfuhr:Kiaheizen_connect_time]:(([$SELF:ui_timer_mode] ne "Aus")?"Klimatisierung ".[$SELF:timer_04_c04]:""))|FUNC_tire("Kia_connect")." ".FUNC_door("Kia_connect")|\
"12 V<div style='border-width:2px;;border-style:solid;;border-color:gray;;position:relative;;width:90px;;height:20px;;background:linear-gradient( to right, red 0px,yellow 30px,green 50px);;'>".STY(" ",FUNC_batt([Kia_connect:bat12v])).STY(::round([Kia_connect:bat12v],0)."%","font-size:16px;;position:absolute;;top:2px;;left:30px")."</div>"\
\
|"<dd> Auswahl / Temperatur / Klima Status / Temperatur innen</dd>"| widget([$SELF:ui_command_2],"uzsuDropDown,---,stopClimate,startHeating,startCooling")|\
"Heat".widget([Kia_connect:status_airTemp_value_target_Winter],"selectnumbers,20,1,27,0,lin")."°C Cool".widget([Kia_connect:status_airTemp_value_target_Sommer],"selectnumbers,16,1,25,0,lin")."°C"|(([Kia_connect:status_airCtrlOn] eq "true")?'Klima läuft':'Klima aus')." ".(([Kia_connect:status_defrost] eq "true")?'Defrost ein':'Defrost aus') |"Aktuell ".[Kia_connect:status_airTemp_value]."°C"\
\
|"WallBox (WB_1_lp1)<dd>Lademodus / Info Status / Ladezeit / Leistung</dd>"|[WB_1:ChargeMode]." ".widget([$SELF:ui_command_4],"uzsuDropDown,---,SofortLaden,Min+PV,NurPV,Stop,Standby,Vorrang_EV,Vorrang_Bat,Hausspeicher_Sperren")|[WB_1:lp_1_PlugStat]." ".[WB_1:lp_1_ChargeStat]|[WB_1:lp_1_TimeRemaining]|[WB_1:lp_1_countPhasesInUse]."P ".[WB_1:lp_1_AConfigured]."A ".[WB_1:lp_1_W]." W"

setstate Kia_eNiro_PV 2022-01-12 13:24:24 ui_command_1 ---
setstate Kia_eNiro_PV 2022-01-10 09:18:53 ui_command_2 ---
setstate Kia_eNiro_PV 2021-11-09 07:56:54 ui_command_3 ---
setstate Kia_eNiro_PV 2022-01-12 13:02:41 ui_command_4 ---
setstate Kia_eNiro_PV 2022-01-12 13:02:41 ui_command_before_4 ---
setstate Kia_eNiro_PV 2021-11-29 09:56:58 ui_timer_Start 10:30
setstate Kia_eNiro_PV 2021-12-02 07:00:00 ui_timer_mode Aus
</syntaxhighlight>

=====Kostal Plenticore mit Speicher=====
Zu diesem Thema gibt es noch die Wiki Seite [[Kostal Plenticore Plus]], die alles rund um den Wechselrichter und vieles mehr erklärt.
Die hier beschriebene openWB und Kia connect Anbindung bedient sich der Hausspeichersteuerung, um diesen beim Laden der BEV zu sperren.
Im DOIF kann an den entsprechenden Stellen natürlich auch ein anders Kommando zum Sperren verwendet werden.

== Weiterführende Links ==
* [https://openwb.de openWB Website]
* [https://github.com/snaptec/openWB/wiki openWB Wiki bei GitHub]
* [https://www.openwb.de/forum/viewtopic.php?f=6&t=4159 openWB Forum (Diskussion zu diesem Artikel)]
* [https://openwb.de/forum/viewtopic.php?t=577 openWB Forum (Liste der MQTT-Topics)]

[[Kategorie:Elektromobilität]]
[[Kategorie:HOWTOS]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2024-11-17T11:31:32Z

Ch.eick: /* MySQL Kommandos */

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="sql">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+

mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.'dwd_load' TO 'fhemuser'@'%'; <<<< Das beschränkt auf nur eine Prozedure

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+

-- Es könnte auch gut sein einen extra root user anzulegen, um mit DbRep die MySQL Datenbank zu optimieren

mysql> CREATE USER 'fhemroot'@'<IP Adresse>' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> GRANT ALL PRIVILEGES ON `fhem`.* TO 'fhemroot'@'<IP Adresse>' WITH GRANT OPTION;
mysql> GRANT SHOW_ROUTINE ON *.* TO 'fhemroot'@'<IP Adresse>';
mysql> GRANT EXECUTE, CREATE ROUTINE, ALTER ROUTINE ON `fhem`.* TO 'fhemroot'@'<IP Adresse>';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

mysql> SELECT user,host FROM mysql.user;
+------------------+----------------+
| user | host |
+------------------+----------------+
| fhemuser | % |
| fhemroot | 192.168.178.57 | <<< Das sollte man dann auf eine IP einschränken.
| root | localhost |
+------------------+----------------+

-- Hier kann man mal seine Proceduren auflisten
mysql> SHOW PROCEDURE STATUS WHERE Db = 'fhem';

</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wird mit folgenden Parametern aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
</pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2024-11-17T11:28:11Z

Ch.eick: /* MySQL Kommandos */

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="sql">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+

mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.'dwd_load' TO 'fhemuser'@'%'; <<<< Das beschränkt auf nur eine Prozedure

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+

-- Es könnte auch gut sein einen extra root user anzulegen, um mit DbRep die MySQL Datenbank zu optimieren

mysql> CREATE USER 'fhemroot'@'<IP Adresse>' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> GRANT ALL PRIVILEGES ON `fhem`.* TO 'fhemroot'@'<IP Adresse>' WITH GRANT OPTION;
mysql> GRANT SHOW_ROUTINE ON *.* TO 'fhemroot'@'<IP Adresse>';
mysql> GRANT EXECUTE, CREATE ROUTINE, ALTER ROUTINE ON `fhem`.* TO 'fhemroot'@'<IP Adresse>';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

mysql> SELECT user,host FROM mysql.user;
+------------------+----------------+
| user | host |
+------------------+----------------+
| fhemuser | % |
| fhemroot | 192.168.178.57 | <<< Das sollte man dann auf eine IP einschränken.
| root | localhost |
+------------------+----------------+

</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wird mit folgenden Parametern aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
</pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2024-11-17T11:08:51Z

Ch.eick: /* MySQL Kommandos */

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="sql">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+

mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.'dwd_load' TO 'fhemuser'@'%'; <<<< Das beschränkt auf nur eine Prozedure

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+

-- Es könnte auch gut sein einen extra root user anzulegen, um mit DbRep die MySQL Datenbank zu optimieren

mysql> CREATE USER 'fhemroot'@'<IP Adresse>' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> GRANT ALL PRIVILEGES ON `fhem`.* TO 'fhemroot'@'<IP Adresse>' WITH GRANT OPTION;
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemroot'@'<IP Adresse>';
mysql> GRANT EXECUTE ON `fhem`.* TO 'fhemroot'@'<IP Adresse>';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

mysql> SELECT user,host FROM mysql.user;
+------------------+----------------+
| user | host |
+------------------+----------------+
| fhemuser | % |
| fhemroot | 192.168.178.57 | <<< Das sollte man dann auf eine IP einschränken.
| root | localhost |
+------------------+----------------+

</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wird mit folgenden Parametern aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
</pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2024-11-17T10:59:27Z

Ch.eick: /* MySQL Kommandos */

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="sql">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+

mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.`dwd_load` TO 'fhemuser'@'%';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+

-- Es könnte auch gut sein einen extra root user anzulegen, um mit DbRep die MySQL Datenbank zu optimieren

mysql> CREATE USER 'fhemroot'@'<IP Adresse>' IDENTIFIED WITH mysql_native_password BY '<password>';

mysql> GRANT ALL PRIVILEGES ON `fhem`.* TO 'fhemroot'@'<IP Adresse>' WITH GRANT OPTION;

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

mysql> SELECT user,host FROM mysql.user;
+------------------+----------------+
| user | host |
+------------------+----------------+
| fhemuser | % |
| fhemroot | 192.168.178.57 | <<< Das sollte man dann auf eine IP einschränken.
| root | localhost |
+------------------+----------------+

</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wird mit folgenden Parametern aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
</pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2024-02-28T17:58:26Z

Ch.eick:

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="SQL">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen
mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%';

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+
1 row in set (0.00 sec)

mysql> UPDATE mysql.user SET plugin = 'mysql_native_password' WHERE User='fhemuser';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

mysql> ALTER USER 'fhemuser'@'%' IDENTIFIED BY '< Password >';

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.`dwd_load` TO 'fhemuser'@'%';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+
1 row in set (0.01 sec)
</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wir mit folgenden Paramerter aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
</syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
<pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
</syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
</syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
</syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]

Kostal Plenticore 10 Plus

2024-02-28T17:55:44Z

Ch.eick:

[[Bild:Kostal Flow.PNG|mini|700px|rechts|Sowas könnte am Schluss raus kommen. Schreibt mich gerne an ;-)]]
{{Infobox Hardware
|Bild=Kostal_Plenticore_10_Plus.jpg
|Bildbeschreibung=Kostal Plenticore Plus
|HWProtocol=IP und RS485
|HWType=Hybrid Wechselrichter
|HWCategory=Wechselrichter
|HWComm=n/a
|HWChannels=n/a
|HWVoltage=400 V
|HWPowerConsumption=
|HWPoweredBy=3P AC
|HWSize=56,3x40,5x23,3 cm (BxHxT)
|HWDeviceFHEM=[[HTTPMOD]], [[Modbus]], [[Perl]]
|HWManufacturer=KOSTAL Solar Electric GmbH
}}
[[Datei:Leistung und Hauptverbraucher.png|mini|700px|rechts|]]
[[Datei:Forecast.png|mini|700px|rechts|]]
[[Bild:WR 1.PNG|mini|900px|rechts|Wechselrichter 1 mit Status]]
[[Bild:WR 1 Speicher 1.PNG|mini|900px|rechts|WR_1_Speicher_1_ExternControl]]
[[Bild:WR 2.PNG|mini|900px|rechts|Wechselrichter 2 und gesteuerte Geräte]]
[[Bild:Kia.PNG|mini|900px|rechts|WallBox mit Kia Fahrzeug]]
[[Bild:Geräte.PNG|mini|900px|rechts|PV gesteuerte Geräte]]

Ein Hinweis allgemeiner Art: Die hier abgebildeten Code Stücke sind nicht ausschließlich durch mich entstanden. Ich bedanke mich für die Unterstützung und Bereitstellung vieler Einzelkomponenten durch Dritte. Der Einsatz ist auf eigene Gefahr und für etwaige Schäden wird keinerlei Haftung übernommen. Bitte beachtet bei der Hardware die Gewährleistungsbestimmungen und Vorgaben der Hersteller.

Der [[Kostal Plenticore 10 Plus|Kostal Plenticore Plus]] ([https://www.kostal-solar-electric.com/de-de/produkte/hybrid-wechselrichter/plenticore-plus/ Webseite des Herstellers]) ist ein Hybrid Wechselrichter mit IP-Konnektivität.

Er verfügt über einen LAN-Anschluss und ist auf die Steuerung via WebGUI des Herstellers ausgelegt. Weiterhin kann eine Abfrage mit Modbus/TCP oder auch über eine undokumentierte API erfolgen. Für die API bietet der Hersteller keinerlei Support!

==Voraussetzungen Energietechnik==
Der Wechselrichter, Speicher und KSEM wurden durch einen Fachbetrieb installiert und konfiguriert. Die gesamte Anlage läuft fehlerfrei und wurde durch den Fachbetrieb abgenommen, sowie beim Netzbetreiber angemeldet.

==Geräte-Registrierung==
Hierfür ist die Dokumentation des Herstellers heranzuziehen. Für eine Verlängerung der Gewährleistungszeit kann man den Plenticore im Herstellerportal registrieren. Dies ist jedoch für die Anbindung an FHEM nicht notwendig.
Weiterhin ist der Betreiber verpflichtet, eine Anmeldung im Marktstammdatenregister vorzunehmen.

==Hersteller Dokumentation==
Für Links auf dieser Wiki Seite wird keine Haftung übernommen. Die Inhalte unterliegen der Verantwortung der Firma Kostal.
* [https://www.kostal-solar-electric.com/de-de/service-und-support/smart-warranty/ Plenticore Plus - Verlängerung der Gewährleistungszeit]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/14/plenticore-plus_ba_de.pdf/ Plenticore Plus - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2021/02/04/10/49/lf_verschaltung-mehrerer-kostal-wechselrichter_de.pdf/ Plenticore Plus - Verschaltung und Einrichtung mehrerer KOSTAL-Wechselrichter]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/06/plenticore-plus_kba.pdf/ Plenticore Plus - Kurzanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/06/db_plenticore-plus_de.pdf/ Plenticore Plus - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/42/kostal_update_plenticore_piko_iq_012106586.swu/ Plenticore Plus - Software Update 01.21]

* [https://www.kostal-solar-electric.com/de-de/download/download/-/media/document-library-folder---kse/2020/12/15/13/38/ba_kostal-interface-description-modbus-tcp_sunspec_hybrid.pdf/ Plenticore - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-ba_de.pdf/ KSEM - Betriebsanleitung]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/13/41/ksem-db_de.pdf/ KSEM - Datenblatt]
* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/13/kostal_update_ksem_1_3_0.raucb/ KSEM - Software Update - 1.3.0]

* [https://www.kostal-solar-electric.com/de-de/download/-/media/document-library-folder---kse/2020/12/15/14/22/ba_kostal_interface_ksem_de.pdf/ KSEM - Modbus\/ Sunspec]

* [https://www.kostal-solar-electric.com/de-de/service-und-support/kontakt/ Kostal - Service Kontakt]

==Kompatibilität zu anderen Kostal Wechselrichtern==
Auf Grund von Anfragen scheint diese Implementierung auch für andere Kostal Wechselrichtern zu passen.
- Plenticore Plus
- Piko MP
- Piko IQ
Dies hängt natürlich mit der Firmware zusammen und es gibt sicherlich noch einige Anpassungen die notwendig sind. Bitte tragt Eure kompatieblen Geräte hier ein.

==Einbindung in das Netzwerk==
Als Grundlage ist der Plenticore mit dem LAN zu verbinden, wodurch er eine TCP/IP Adresse per DHCP bekommt. Diese ist dann entweder am Display des Plenticore abzulesen, oder über die Oberfläche des Routers zu ermitteln.

Das gleiche gilt für den BYD Speicher, der jedoch zusätzlich auch über WLAN verfügt. Eine Netzwerkanbindung des Speichers ist beim Plenticore nicht zwingend notwendig, da der Plenticore mit dem Speicher über eine RS-485 Schnittstelle kommuniziert. Bei dieser Anbindung werden jedoch noch nicht alle möglichen Werte aus dem Speicher ausgelesen. Später wird hierzu jedoch noch mehr geschrieben, um alle Möglichkeiten offen zu halten.

Der KSEM kann ebenfalls auch direkt per LAN ausgelesen werden, was jedoch ebenfalls nicht zwingend notwendig ist. Eine Kommunikation des KSEM mit dem Plenticore erfolgt über zwei mögliche Wege. Beim Betrieb mit Speicher ist zwingend die RS485 Schnittstelle erforderlich, über die auch der Plenticore alle Werte übermittelt bekommt. Auch diese sind dann am Plenticore abfragbar. Der zweite Weg wäre dann über die LAN Verbindung, bei der jedoch kein Speicher am Plenticore konfigurierbar ist.

==Namensgebung==
Im Laufe der Zeit hat sich herausgestellt, dass es einfacher ist, die hier vorgeschlagenen Namen zu übernehmen. Es vereinfacht die Kommunikation bei der Hilfestellung und erspart einigen Umbenennungsaufwand, da es doch immer wieder zu Anpassungen kommt. Leider musste in der letzten Zeit durch das Wachsen des Umfeldes und durch anfängliche Unwissenheit auch viel aufgeräumt werden.

==Voraussetzungen FHEM Umfeld==
===Alle Geräte müssen mit TCP/IP erreichbar sein===
===Alle Module sollten auf einem aktuellen Stand sein===
===Eine DbLog/DbRep sollte bereits vorhanden sein, was hier nicht weiter erklärt wird===
Es wurde immer wieder gefragt, ob man auch FileLog verwenden könnte, was grundsätzlich natürlich geht. Im Fortschreiten wird dies jedoch ziemlich unhandlich und vom Modulautor nicht empfohlen. Spätestens wenn die Daten mal aufgeräumt werden sollen, ist man mit einer MySQL Datenbank im Vorteil. Auch die Aufbereitung von Diagrammen ist mit einer Datenbank flexibler.
Weiterhin wird empfohlen eine vollwertige MySQL Datenbank zu verwenden, damit auch komplexeres Reporting im vollen SQL Umfang zur Verfügung steht. Beim Einsatz von SQLite sind bereits zumindest bei den Reports inkompatibilitäten aufgetreten. MariaDB sollte immer auch aktuell gehalten werden, was auf einem RPI 32 Bit nicht immer gewährleistet ist. Die größte aktualität erhält man mit dem original MySQL Docker Container, der auch auf einem RPI4 64 Bit verfügbar ist. Beim Einsatz einer Datenbank sollte man dies auf keinen Fall auf einer SD-Card machen. die besten Ergebnisse für Geschwindigkeit und Langlebigkeit bekommt man mit einer SSD.

===Verwendete Module===
* Modbus
* HTTPMOD
* expandJSON
* DbLog
* DbRep
* DUMMY
* DOIF
* Shelly
* SMAEM
* HourCounter
* DWD_OpenData
* WeekdayTimer

===Verwendetes Umfeld===
* Raspberry Pi 4
* Debian
* Docker
:: fhem/fhem:latest
:: mysql/mysql-server
:: grafana/grafana:latest
* Perl
* Python

==Einbindung in FHEM: Überblick==

===MySQL etwas Basis Information===
====Docker Compose nach installieren====
Falls Docker Compose nicht bereits installiert ist.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ sudo apt-get install docker-compose
Paketlisten werden gelesen... Fertig
Abhängigkeitsbaum wird aufgebaut.
Statusinformationen werden eingelesen.... Fertig
docker-compose ist schon die neueste Version (1.21.0-3).
</syntaxhighlight>
https://docs.docker.com/engine/reference/commandline/compose/

Einige Docker Kommandos:
<pre>
Für den Überblick:
docker stats
docker ps

Zum aktualisieren (nur ein Beispiel):
docker pull portainer/portainer:latest
docker-compose up -d
</pre>

====MySQL Docker Container mit .yml====
Hier wäre mal ein Beispiel, wie die MySQL Datenbank innerhalb einer .yml Datei im Docker definiert werden kann. Im Beispiel ist FHEM und Portainer ebenfalls enthalten, wodurch dies auch somit eine Basis Installation sein könnte.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Docker/docker-compose.yml Beispiel für eine docker-compose.yml]
<syntaxhighlight lang="Perl">
pi@raspberrypi:~/docker-compose/fhem_2022 $ pwd
/home/pi/docker-compose/fhem_2022
pi@raspberrypi:~/docker-compose/fhem_2022 $ ls -l docker-compose.yml
</syntaxhighlight>

====Administration etwas erleichtern====
In der /etc/passwd habe ich dann noch ein Login und die Home Verzeichnisse für einige Container eingetragen. Somit kann man sich dann auf dem Basis Betriebsystem mit diesem Benutzer anmelden und das Dateisystem des Docker Containers direkt bearbeiten. Der Home Path muss natürlich angepasst werden.
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ cat /etc/passwd
< snip >
fhem:x:6061:6061:FHEM,,,:/home/pi/docker-compose/fhem_2024/fhem:/bin/bash
</syntaxhighlight>

====MySQL initial konfigurieren====
Wenn der MySQL Docker Container läuft sind dort noch die Basis Konfigurationen für DbLog durchzuführen, für die es ein eigenes FHEM Wiki gibt. Einige wichtige Kommandos sollen nun jetzt hier trotzdem aufgelistet werden.
=====MySQL Docker Console für MySQL root Login=====
Achtung
<pre>
Die Basis Konfiguration wird mit dem Benutzer root im MySQL durchgeführt und dieser kann sich bei Oracle MySQL nur lokal, also nicht aus dem Netz anmelden.
</pre>
Dazu gibt es zwei Varianten:
1. Über den Docker Container anmelden
<syntaxhighlight lang="Perl">
pi@raspberrypi:~ $ docker exec -it fhem_2022_mysql_1 mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 17517
Server version: 8.0.32 MySQL Community Server - GPL
mysql>
</syntaxhighlight>
2. Oder man meldet sich am Portainerzugang (admin mit <Passwort>) an und selectiert den MySQL Container. Dort kann man dann mit der Console in den Container wechseln.
<syntaxhighlight lang="Perl">
bash-4.4# mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 44892
Server version: 8.0.28 MySQL Community Server - GPL
mysql>
</syntaxhighlight>

=====MySQL Kommandos=====
<syntaxhighlight lang="SQL">
-- Die fhem Datenbank neu anlegen
mysql> CREATE DATABASE `fhem` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;

-- Die FHEM Tabellen neu anlegen
-- Für die Spalte VALUE wurde mal eine längere Definition gewählt
mysql> CREATE TABLE `fhem`.`history` (TIMESTAMP TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(255), UNIT varchar(32));
mysql> CREATE TABLE `fhem`.`current` (TIMESTAMP TIMESTAMP, DEVICE varchar(64), TYPE varchar(64), EVENT varchar(512), READING varchar(64), VALUE varchar(128), UNIT varchar(32));

-- Den Index einrichten und über das READING mit definieren, damit kein duplicate Key entstehen kann
mysql> CREATE INDEX Search_Idx ON `fhem`.`history` (TIMESTAMP, DEVICE, READING) USING BTREE;
Query OK, 0 rows affected (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

-- Im Oracle MySQL wird im Standard das Passwort in einer anderen Verschlüsselung abgeregt, die FHEM noch nicht unterstützt
-- Deshalb kann es erforderlich sein das Passwort, nach Änderung der Verschlüsselungsmethode neu zu setzen
mysql> DROP USER fhemuser;
mysql> CREATE USER 'fhemuser'@'%';

-- Nachschauen welche Passwort Verschlüsselung verwendet wird
-- FHEM unterstützt nur mysql_native_password
mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | caching_sha2_password | <<< Das unterstützt FHEM mit DbLog noch nicht
+------+----------+-----------------------+
1 row in set (0.00 sec)

mysql> UPDATE mysql.user SET plugin = 'mysql_native_password' WHERE User='fhemuser';

mysql> SELECT Host,User,plugin FROM mysql.user WHERE User='fhemuser';
+------+----------+-----------------------+
| Host | User | plugin |
+------+----------+-----------------------+
| % | fhemuser | mysql_native_password |
+------+----------+-----------------------+
1 row in set (0.01 sec)

mysql> ALTER USER 'fhemuser'@'%' IDENTIFIED BY '< Password >';

-- Bei den GRANDS muss ich nochmal nachschauen, was da wirklich notwendig ist
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT ALTER ROUTINE ON `fhem`.* TO 'fhemuser'@'%';
mysql> GRANT EXECUTE ON PROCEDURE `fhem`.`dwd_load` TO 'fhemuser'@'%';

-- Die Änderungen müssen mit einem FLUSH in der aktuellen Session übernommen werden
mysql> FLUSH PRIVILEGES;

-- Alle Einträge für den fhemuser anschauen
mysql> SELECT * FROM mysql.user WHERE User='fhemuser';
< snip >
Es wird eine Tabelle mit den user Einträgen für fhemuser angezeigt, die man sich besser in voller Breite im Editor anschaut

mysql> Connect fhem;
Enter password:
Connection id: 44902
Current database: fhem

-- Zum Test mal einige Einträge in der history anzeigen, wenn FHEM bereits was über DbLog geschieben hat
mysql> SELECT * FROM history LIMIT 1;
+---------------------+------------------+---------+-------+-----------------+----------+------+
| TIMESTAMP | DEVICE | TYPE | EVENT | READING | VALUE | UNIT |
+---------------------+------------------+---------+-------+-----------------+----------+------+
| 2019-04-03 00:23:42 | EVU_StromZaehler | HTTPMOD | NULL | Strom_Status-02 | 07152.96 | |
+---------------------+------------------+---------+-------+-----------------+----------+------+
1 row in set (0.01 sec)
</syntaxhighlight>

===Hardware Anbindung (alles über LAN)===
====Kostal Plenticore Plus====
=====Kostal Plenticore Plus die Basis information (Modbus/TCP)=====
Der Kostal Plenticore wird mittels des Moduls MODBUS eingebunden. Dazu gilt zunächst die folgende Konfiguration als Basis, die am Display des Plenticore oder auch in der Kostal Dokumentation zu entnehmen ist.

======Plenticore Modbus Definition======
<pre>
GeräteId : 71
IP-Adresse: <IP-Adresse>
Port : 1502
</pre>

====Ein zweiter Wechselrichter====
Durch einen Vollausbau des Daches ist ein zweiter Wechselrichter hinzugekommen. Das hat einen Umbau dieser Wiki Seite erfordert, wodurch sich diverse Änderungen bei der Namensgebung ergeben haben. Es ist jedoch auch weiterhin möglich, nur eine AC-Quelle zu verwenden, was an einigen Stellen entweder einen Rückbau in den Devices erfordert oder man freundet sich mit etwas anderen reading Namen an.

======Modbus Timeing======
Das Gerät aktualisiert sich im Abstand von 60 Sekunden durch den stetigen Modbus/TCP Datenstrom. Der Plenticore ist als Modbus Master implementiert und sendet somit alle Daten permanent ins Netzwerk.

Die Zeit kann auch verändert werden, jedoch sollte sie nicht zu kurz gewählt sein.

======RAW Definition WR_1 (bei einem Wechselrichtern)======
Generell kann die WR_1 und WR_1_API Definition, die im folgenden kommt auch für einen einzelnen Wechselrichter verwendet werden. Wer die readings für die Korrektur mit zwei AC-Quellen nicht haben möchte, der kann diese gerne wieder entfernen, was dann jedoch bei jedem Update immer wieder gemacht werden muss. Achtung es können dann jedoch Abweichungen bei der Plausibilität einzelner Readings auftreten. Alle stateFormat und weiteren DOIF Devices beziehen sich hierbei jedoch ebenfalls auf die SW_* readings, um die Implementierung für mehr Anwender verwendbar zu machen. Diejenigen unter Euch, die auch einen nicht Kostal Wechselrichter verwenden sollten sich bitte die userReadings anschauen, um dort die readings korrekt zu mappen. Es sollte auch kein Problem sein als zweite AC-Quelle ein Krafwärmekopplung ein zu binden.

Anzupassende Stellen, wenn man lieber keinen Schwarm vorbereiten möchte:
<pre>
WR_1 und WR_1_API:
- userReadings SW_* löschen
- deletereading WR_1 SW_*
- stateFormat bei readings mit SW_* das SW_ löschen
- DbLogInclude überprüfen
- event-on-update-reading überprüfen
PV_Schedule:
- cmd_5 für die Zählerstände löschen
DbLog:
- Eventuell die Datenbank aufräumen
</pre>

======RAW Definition WR_1 Master (bei zwei Wechselrichtern)======
Für den Zugriff auf die Plenticore ModBus/TCP Daten wird dieses Device verwendet.
Es kann für einen einzelnen oder auch mehrere Wechselrichter verwendet werden. Readings mit SW_* korrigieren die bisher fehlerhaften Ausgabewerte der Kostal Wechselrichter im Schwarm. Bei Verwendung nur eines einzelnen Wechselrichters können diese jedoch auch verwendet werden. Die Original readings sind auch weiterhin noch vorhanden, was jedoch zu einer Befüllung mit gleichen Werten führen kann. Damit diese nicht doppelt in der Datenbank landen, kann man das DbLogInclude entsprechend anpassen, nachdem man sich entschieden hat, welche Richtung man einschlagen möchte.
Letzte Änderungen:
<pre>
- Bei den readings wurden ungültige Zeichen aus den Namen entfernt, wie z.B. "()"
Wer das bei sich ändert muss natürlich auch in der Datenbank aufräumen.
- Einige readings wurden eingekürzt z.B. P,U,I,L*
- SW_* gibt die korrigierten werte bei mehr als einer AC-Quelle an
- DbLogInclude logged nun auch SW_* und die eingekürzten reading Namen
- PV wurde zu WR, da eine PV-Anlage aus mehreren Wechselrichtern bestehen kann
- stateFormat und userReadings verwenden jetzt die SW_* readings
</pre>

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1.txt Beispiel für WR_1]

======userReadings======
Um später einige Abfragen und Diagramme einfacher zu erstellen wurden einige userReadings erstellt, die bereits bei der RAW Definition mit vorhanden sind. Während der Integration in FHEM und der Konfiguration kann es hierdurch jedoch noch Fehlermeldungen im FHEM Log geben, da noch nicht alle Werte vorhanden sind.

Total_PV_Power_reserve
Trigger: Total_DC_Power.*
Hier wird ein reading erstellt, dass als Information über die verwendbare Reserve dient. Die Leistung, die in den Speicher geht
sollte man nämlich besser sofort verbrauchen, anstatt es erst zu speicher. Die 0.90 ist ein circa Wirkungsgrad, um von DC- auf AC-Leistung zu kommen.
Der Total_PV_Power_reserve Wert kann gerne nach eigenen Belangen kalkuliert werden.
Total_DC_Power_Max
Trigger: Total_DC_Power.*
Um die Batterieleistung mit zu berücksichtigen wird dieser Momentan Wert ermittelt.
Actual_Battery_charge_-minus_or_discharge_-plus_Power
Trigger: Actual_Battery_charge_-minus_or_discharge_-plus_current.*
Berechnung der Batterie Leistung aus Spannung und Strom , der wert kann positiv oder negativ sein, je nach dem ob geladen oder entladen wird.
Actual_Battery_charge_usable_Power
Trigger: Act_state_of_charge.*
Dieser Wert gibt an, wieviel Leistung im Speicher vorhanden ist, reduziert um 10% Verluste. An dieser Stelle muss die Nennleistung des Speichers über das PV_1_config Gerät
eingetragen werden, da diese noch nicht ausgelesen werden kann. Obwohl es im "Battery_Type 892941625" stecken könnte. 8929 >> 8.93 KW ???
SW_*
Bei mehreren Wechselrichtern werden einige Werte vom Plenticore fehlerhaft ermittelt und durch diese readings korrigiert.
Wann Kostal das in der Firmware korrigiert ist nicht bekannt.

======RAW Definition WR_2 Slave (bei zwei Wechselrichtern)======
In einem Schwarm kann man den zweiten Wechselrichter etwas sparsamer definieren, da es nur einen Wechselrichter mit Speicher geben darf und der zweite Wechselrichter auch keine KSEM Verbindung hat. Auch die SW_* readings werden hier nicht benötigt. Im userReading des WR_1 und WR_1_API wird auch auf den WR_2 und WR_2_API referenziert.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2.txt Beispiel für WR_2]

=====Kostal Plenticore Plus die API=====
Der Plenticore erstellt intern noch diverse Statistiken, die auch über das WebGUI angesehen werden können. Diese werden jedoch nicht über MODBUS/TCP ausgegeben, aber zum Kostal Portal übermittelt, wo man dann bereits in Form von Diagrammen einen schönen Überblick bekommt. Das Ziel ist jedoch die Statistiken lokal im FHEM abzulegen, sie lassen sich nur über die API des Plenticore abfragen.
Auch hier werden bei mehreren AC-Quellen falsche Werte ausgegeben, die durch SW_* userReadings korrigiert wurden.

======Plenticore API======
Die API Definition kann man sich mit folgendem Aufruf anschauen, sie wird von Kostal jedoch nicht supportet.
<syntaxhighlight lang="Perl">
http://<IP-Address_Plenticore>/api/v1
</syntaxhighlight>

======Plenticore Testablauf======
Für die erste Implementierung ist es zu empfehlen alle Devices so zu belassen und zu benennen, wie sie im Wiki angegeben sind.
Eine persönliche Anpassung ist erst sinnvoll, wenn alles läuft, da hierdurch bereits schon im Vorfeld viele Fehler verursacht wurden, die eine Unterstützung erschweren.

Folgendes bitte aktivieren, damit genügend Meldungen zusehen sind
<syntaxhighlight lang="Perl">
attr global verbose 3
attr <device> verbose 5
</syntaxhighlight>
Bitte unbedingt bei Problemen den Log Ausschnitt mit senden und die Meldungen anderer Devices vorher herauslöschen, da es ansonsten schwierig ist eine Diagnose zu betreiben.
Tests sind bei den einzelnen Schritten direkt mit angegeben.

======plenticore_auth() und KeyValue() Voraussetzung======
Diese Einträge müssen, falls noch nicht vorhanden in die 99_myUtils eingetragen werden. Hierdurch lädt man zusätzliche, nicht Standardfunktionen aus Perl Bibliotheken in ein Modul.
<syntaxhighlight lang="Perl">
* use Encode qw(decode encode);
* use PBKDF2::Tiny qw/derive verify/;
* use Digest::SHA qw(sha256 hmac_sha256);
* use Crypt::URandom qw( urandom );
* use Crypt::AuthEnc::GCM;
</syntaxhighlight>
Je nach dem welche Installation Ihr verwendet kann es auch sein, dass noch weitere Module installiert werden müssen. Es wurde bereits folgendes gemeldet.
<syntaxhighlight lang="Perl">
* sudo apt-get install libcryptx-perl
* sudo apt-get install libpbkdf2-tiny-perl
* sudo apt-get install libcrypt-urandom-perl
</syntaxhighlight>

======KeyValue() Erläuterung Passworte======
Das Passwort für den Plenticore wird mit der Funktion KeyValue() im KeyStore vom FHEM abgelegt und ausgelesen. '''Bitte beachtet, dass dies kein Schutz gegen das Stehlen von Passworten ist.''' Es dient lediglich der Ablage von Keys, damit sie nicht direkt offen im Datensystem oder im Konfigurationsfile zu finden sind.
Die Funktion befindet sich in der 99_myUtils .

======KeyValue()======
Die KeyValue() Funktion kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======KeyValue() Test======
Die Funktion befindet sich in der 99_myUtils und kann auch direkt in der Commandline von FHEM aufgerufen werden.
Der Syntax von "PW_<device>_<key>" ist so beizubehalten. '''Beim Umbenennen der WR_1_API Device ist hier dann auch das Passwort neu im KeyStore abzulegen.'''
Der Key "user" ist die Benutzerkennung des "Anlagenbetreibers" im Plenticore. Bei der Anmeldung am Plenticore Web Interface wird "Anlagenbetreiber" ausgewählt, jedoch wird dies im Hintergrund auf den Benutzernamen "user" gemapped. '''Somit ist für die API "user" zu verwenden und das Passwort des Anlagenbetreibers vom Web-GUI'''. Oft entspricht das Passwort des Anlagenbetreibers dem "Master Key" der sich auf dem Aufkleber des Plenticore befindet. Sollte das nicht der Fall sein, so kann man auch das Passwort auf den "Master Key" zurück setzen.
<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM {KeyValue("[read|store]","PW_<device>_<key>","<password>")}
{KeyValue("store","PW_WR_1_API_user","<passwort>")}
{KeyValue("read","PW_WR_1_API_user")}
</syntaxhighlight>
'''Wenn das Passwort aus dem KeyStore mit read abgeholt wird, wird es im Klartext angezeigt!''' Dies muss einzeilig und identisch zum Passwort des Anlagenbetreibers vom Web-GUI erscheinen. Bei etwaigen Sonderzeichen kam es hier schon zu Abweichungen. In solch einem Fall muss man dann leider das Passwort des Anlagenbetreibers vom Web-GUI im Plenticore ändern.

======plenticore_auth() Erläuterung======
Diese Funktion befindet sich in der 99_myUtils und dient der Erstellung von Keys für die mehrstufige Anmeldung des Kostal Plenticore Plus.

======plenticore_auth()======
Für die Abfrage des KeyValue gab es hier direkt am Anfang der Funktion eine Änderung (2021.04.07). Auch das Logging wurde verändert und kann nun durch das Setzen von "attr WR_1_API verbose 5" aktiviert werden.

Die plenticore_auth() kommt in die 99_myUtils.pm .
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/99_myUtils.pm_Erg%c3%a4nzungen.txt Beispiel 99_myUtils.pm Ergänzungen]

======plenticore_auth() Test======
Nachdem vorher bereits mit KeyValue() das Passwort hinterlegt und getestet wurde kann man die Funktion bereits überprüfen.
Die Anzahl der Argumente ist je nach gewünschter Funktionalität (start|finish|session) unterschiedlich.
Da die auth_* Keys zur Laufzeit im Dialog mit dem Plenticore erstellt und ausgetauscht werden, wird hier für den Test mit Beispielwerten gearbeitet

<syntaxhighlight lang="Perl">
Syntax für die Commandline im FHEM:
{plenticore_auth("[start|finish|session]","user","<device>","auth_randomString64","auth_nonce","auth_salt","auth_rounds","auth_transactionId","auth_token")}
Test 1)
{plenticore_auth("start","user","WR_1_API")} # Im Hintergrund wird das Passwort aus dem KeyStore verwendet
>>> {"nonce": "UUZ1dWNEZnowVzh2","username": "user"}

Test 2)
{plenticore_auth("finish","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "proof": "5xZeOxoyR0hzPCVqvD/BPMqscQbT57wSONl049xiLjE="}

Test 3)
{plenticore_auth("session","user","WR_1_API","TESMUWZnwkJZbnpF","TE2MUWZnwkJZbnpFQ5ulCfolNNdAD0vT","DbAC0R85jwF0rh+r","29000","1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43","acafc66c0e1975293d35512a1e4bcceea55840b3109a703514e75b5ebce9b7c5")}
>>> {"transactionId": "1376720346bea40cdf770a8f84b5975cfeb20c5e6ac6d89b7862df3ca9695e43", "iv": "ckS6b3PIzcR7Iy4TEUUZOQ==", "tag": "ROTpRrav38sLdt3EEuE3tQ==", "payload": "nWraowAhLQVk5RCq8WOo8ZhGvUyHLMNxA13/21w7DuHDqq2LOQRXM143kJE5WNJQgeuoKeLiRunPaRpiJUzK3g=="}
</syntaxhighlight>

======Ablaufbeschreibung WR_1_API======
Hier soll ein kurzer Überblick für den Anmeldeablauf geschaffen werden. Die mehrstufige Anmeldung wird vom HTTPMOD Modul über sid01 bis sid03 abgebildet. Die Keys werden dabei zwischen den Devices ausgetauscht und mit replacements in das HTML eingefügt. Das replacement ruft dafür noch die Funktion plenticore_auth() aus der 99_myUtils auf.
======Automatischer Login mit Sessionaufbau======
Der Ablauf startet mit einer beliebigen Abfrage und läuft dann vollautomatisch bis zur Ausführung des eigentlichen Aufrufes durch.
<pre>
1. get WR_1_API 20_Statistic_EnergyFlow
2. Sollte noch keine Session aufgebaut sein erfolgt der Aufruf von sid01
3. Das Replacement %START% führt plenticore_auth("start","user","WR_1_API") aus
4. Die Rückmeldung vom Plenticore wird gelesen
5. Das Replacement %FINISH% führt plenticore_auth("finish","user","WR_1_API",...) aus
6. Die Rückmeldung vom Plenticore wird gelesen
7. Das Replacement %SESSION% führt plenticore_auth("session","user","WR_1_API",...,...) aus
8. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
9. Der eigentliche Aufruf wird ausgeführt und die readings bereit gestellt
</pre>
Die Anmeldung kann auch teil automatisch erfolgen, was bei etwaigen Fehlern in der Anmeldung nützlich ist. Hier sind nur die manuellen Schritte beschrieben, der Ablauf ist identisch zur vorherigen Beschreibung.
<pre>
1. get WR_1_API 01_auth_start
2. get WR_1_API 02_auth_finish
3. get WR_1_API 03_auth_create_session
4. Die Rückmeldung vom Plenticore wird gelesen und es sollte eine SessionId bestehen, mit der nun alle weiteren Abfragen laufen
</pre>

======Implementierte Abfragen======
Sollte die Session abgelaufen, oder noch kein Login vollzogen worden sein, so wird automatisch ein Login mit Sessionaufbau durchgeführt.

'''get:'''
<pre>
Login Funktionalität für eine manuelle Anmeldung
01_auth_start
02_auth_finish
03_auth_create_session

Auskunft über den Anmeldezustand
04_auth_me

Informationen zum Plenticore
05_info_version

Abfrage der Statistiken
20_Statistic_EnergyFlow

Informationen zum Speicher, die auch teilweise gesetzt werden können. Siehe '''set:'''
21_Battery_Information
22_Battery_InternControl
23_Battery_ExternControl
24_Battery_TimeControl
25_Battery_EM_State

Liste aller Plenticore Module. Es werden keine readings erzeugt. Das Ergebnis steht im httpbody, der mit "showBody" angezeigt werden kann. Es erfolgt keine Umsetzung des JSON in readings.
attr <Device> showBody 1
51_modules_list

Hier gibt es viele technische Loggings. Sollte es Probleme beim Abholen der Daten geben kann es am timeout liegen
attr <Device> timeout 7
59_logdata_download

Das zeigt den Firmware Update Status beim FW Laden an. Die Rückmeldung ist im httpbody zu sehen, es werden keine readings erzeugt.
60_update_status
</pre>

'''set:'''
Bei den set Aufrufen ist automatisch ein get Aufruf im Anschluss gekoppelt, wodurch der neue Zustand wieder abgefragt wird.
<pre>
Eine bestehende Session wird abgemeldet, als Rückmeldung erscheint im httpbody nur ein "null"
06_auth_logout

Die letzten Events können in deutsch oder englisch abgeholt werden
23_events latest_5 [en-gb,de-de]

Batterie Einstellungen können verändert werden. Es werden einige Werte vorgeschlagen. Bitte vorher immer den aktuellen Wert abfragen und besser aufschreiben!
Hier sollte nur etwas gesetzt werden, wenn man sich sicher ist, was man tut.
22_01_Battery_DynamicSoc_Enable
22_03_Battery_MinHomeConsumption
22_04_Battery_MinSoc
22_05_Battery_SmartBatteryControl_Enable
22_06_Battery_Strategy
22_07_Battery_Type [0,4]

23_00_Battery_ExternControl
23_01_Battery_ExternControl_AcPowerAbs
23_02_Battery_ExternControl_AcPowerRel
23_03_Battery_ExternControl_DcCurrentAbs
23_04_Battery_ExternControl_DcCurrentRel
23_05_Battery_ExternControl_DcPowerAbs
23_06_Battery_ExternControl_DcPowerRel
23_07_Battery_ExternControl_MaxChargePowerAbs
23_08_Battery_ExternControl_MaxDischargePowerAbs
23_09_Battery_ExternControl_MaxSocRel
23_10_Battery_ExternControl_MinSocRel

Hier kann eine Lister der letzten 5 Events abgeholt werden. Achtung lange Laufzeit, da immer die gesamte Liste abgerufen wird und dort sehr viele Einträge sind.
50_events_latest_5
</pre>

======RAW Definition des WR_1_API Master ab v1.16======
Achtung, wenn Ihr zu dieser Definition wechselt, haben sich die get/set Bezeichnungen geändert. Bitte korrigiert dann auch das PV_Schedule Device entsprechend.
Beim Wechsel auf die v1.16 sind diverse Batterie Funktionalitäten hinzu gekommen, die man jedoch vom Installateur aktivieren lassen muss. Bitte denkt daran, dass der Installateur für jeden Wechsel der Batterie Konfiguration von intern auf extern und zurück, zu Euch kommen muss!

Die Abfrage der Settings für die Batterie ist nun in intern/extern gruppiert und es werden dann mehrere Settings gleichzeitig abgefragt. '''Beim Setzen hingegen erfolgt jedes Setting einzeln und das erfolgreiche Setzen ist am Ende mit einem erneuten get zu überprüfen.''' Stand 2021.04.07 im HTTPMOD wird ein Attribut set[*]FollowGet unterstützt, wodurch nun ein automatisches get nach dem set erfolgt. Dies vereinfacht das Timing, da das set bereits komplett erledigt wurde, bevor der Status neu abgefragt wird.

Die Nummerierung beim get/set soll die Zusammenhänge etwas klarer machen:
<pre>
get 21_Battery_InternControl
set 21_04_Battery_MinSoc (mit automatischem FollowGet)
</pre>

'''Achtung, Voraussetzung ist mindestens die HTTPMOD Version 4.1.00'''

Auch dieses Device ist für den Betrieb mehrerer Wechselrichter vorbereitet. Hierbei sollte der erste WR_1 und der zweite WR_2 benannt werden. Beim Betrieb nur eines Wechselrichters werden die userReadings SW_* ebenfalls befüllt und beinhalten die Werte des ersten Wechselrichters. Somit ist ein Betrieb in beiden Umgebungen möglich. Beim Logging muss man sich entscheiden und DbLogInclude entsprechend setzen, damit die Werte nicht doppelt ins DbLog geschrieben werden. Achtung, dies hat auch Auswirkungen auf die Diagramme.

'''Für die Korrektur der Statistiken werden die Stromzähler Stände des KSEM benötigt''', die als reading mit Active_energy[+|-] bezeichnet sind. Bisher war es nicht erforderlich den KSEM im FHEM per ModBus abzufragen, was jedoch nun notwendig ist. In dieser Integration wurde der KSEM wegen des Schwarms auf WR_0_KSEM benannt. Im Device PV_Schedule wurde ein cmd_5 eingefügt, dass die Zählerstände zum Beginn einer Statistikperiode, Day/Month/Year in das Device WR_1_API überträgt. Initial müssen diese manuell korrekt gesetzt werden, damit die Berechnungen in den userReadings stimmen!
Die Definition des KSEM kommt etwas später im Kapitel [[Kostal_Plenticore_10_Plus#Kostal_Smart_Energy_Manager_.28KSEM.29_.28Modbus.2FTCP.29|Kostal_Smart_Energy_Manager_KSEM_Modbus_TCP]]

'''Sollte der Plenticore mal wegen eines Defektes ausgetauscht werden müssen''', dann beginnt der neue Wechselrichter seine Statistiken wieder bei Null, was natürlich nicht so schön ist. Für die Tages Statistiken *_Day ist das nicht so tragisch, bei Monat und Jahr stört das schon einwenig. Um das dann kontinuierlich hin zu bekommen muss man aus der Datenbank die letzten gültigen Werte heraussuchen und diese manuell im userreading mit einrechnen. Zum Ende des Monats bzw. des Jahres sind dann die Offsets wieder heraus zu nehmen und gegebenenfalls nochmals in der Datenbank zu prüfen.
Betroffen sind die folgenden SW_* userreadings, die hier mit exemplarischen Zahlenwerten korrigiert werden.
Am besten macht Ihr Euch zum Ende der Periode einen Eintrag im Kalender, damit Ihr die Korrektur rechtzeitig wieder raus nehmt.
'''Bei allen anderen userreadings wurde ein solcher Wechsel bereits berücksichtigt und schreibt die Werte mit Hilfe der monotonik Funktion kontinuierlich weiter.'''
<pre>
SW_Statistic_Yield_Month:Statistic_Yield_Month.* { round(ReadingsVal("$NAME","Statistic_Yield_Month",0)+ReadingsVal("WR_2_API","Statistic_Yield_Month",0),0) + 195000},
SW_Statistic_Yield_Year:Statistic_Yield_Year.* { round(ReadingsVal("$NAME","Statistic_Yield_Year",0)+ReadingsVal("WR_2_API","Statistic_Yield_Year",0),0) + 772000},

SW_Statistic_EnergyHomePv_Month:SW_Statistic_EnergyHomeFeedInGrid_Month.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Month",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Month",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0),0) - 42000 },
SW_Statistic_EnergyHomePv_Year:SW_Statistic_EnergyHomeFeedInGrid_Year.* { round(ReadingsVal("$NAME","SW_Statistic_Yield_Year",0) - ReadingsVal("$NAME","SW_Statistic_EnergyHomeFeedInGrid_Year",0) - ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0),0) - 158000 },

SW_Statistic_TotalConsumption_Month:SW_Statistic_EnergyHomePv_Month.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Month",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Month",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Month",0) ),0) + 42000},
SW_Statistic_TotalConsumption_Year:SW_Statistic_EnergyHomePv_Year.* { round( (ReadingsVal("$NAME","SW_Statistic_EnergyHomePv_Year",0)+ReadingsVal("$NAME","Statistic_EnergyHomeBat_Year",0) +ReadingsVal("$NAME","SW_Statistic_EnergyHomeGrid_Year",0) ),0) + 158000},
</pre>

RAW Definition des WR_1_API Master
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_API.txt Beispiel WR_1_API]

Initiales setzen der WR_0_KSEM Zähler Stände. Dies sollte nach einem save config durch das setstate, bei einem restart wieder richtig gesetzt sein. Das ganze neu berechnen der Statistiken ist nur ein Work around, bis Kostal das Problem in der Firmware korrigiert hat.
<syntaxhighlight lang="Perl">
setstate WR_1_API SW_Meter_init_FeedInGrid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_FeedInGrid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_FeedInGrid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
setstate WR_1_API SW_Meter_init_Grid_Day xxxx << Tageswert um 00:01
setstate WR_1_API SW_Meter_init_Grid_Month xxxx << Monatswert um 00:01 am 01. des Monats
setstate WR_1_API SW_Meter_init_Grid_Year xxxx << Jahreswert um 00:01 am 01.01 des Jahres
</syntaxhighlight>

Erweiterung im WR_ctl, um die Zählerstände zu speichern
Im WR_ctl (DOIF im Perl Modus) gibt es einen Block für das Wiederherstellen der Zählerstände aus der DbLog, sofern das Monitoring bereits einen Jahres Zyklus gelaufen ist. Der Block 4_WR_1_API_init_Werte kann über das uiTable Pull Down Menü im WR_ctl im Bereich "WR_1_API Kommando Auswahl" auch manuell ausgeführt werden, was nach einem FHEM Absturz eventuell notwendig sein könnte. Die Notwendigkeit erkennt man an negativen Werten in der Spalte "aktuell".

======DigitalOutputs schalten======
Man kann den Schaltausgangdes Wechselrichtern mit "set 41_01_DigitalOutputs" auch direkt schalten.
Dies ist jedoch keine original Funktion des Wechselrichters, sondert manipuliert die Konfiguration des Schaltausgangs.

Testaufbau: Ne lange Leitung bis ins warme Büro und ein Durchgangsprüfer am Potentialfreien Relais Ausgang des Plenticore.
Nebenergebnis: Der Summer am 40 Jahre alten Messgerät ist kaputt und die Gewährleistung ist rum.
Es soll festgestellt werden, ob man das Relais mit den oben vorgegebenen Angaben Ein- und Ausschalten kann.

Ergebnis: Es funktioniert und konnte sogar noch vereinfacht werden, wenn man das "DigitalOutputs:Customer:ConfigurationFlags '''0'''" verwendet. Alle anderen Parameter dienen lediglich der Basis Konfiguration und wurden im Test einfach per default mitgesendet. Nur "DigitalOutputs:Customer:ConfigurationFlags" wechselt, um das Ein- und Ausschalten zu erreichen.

'''Ausschalten''' wird mit der Sendefolge 9-0 erreicht und schaltet direkt nach der 9 ab. Die oben genannte Abschaltverzögerung wird anscheinend vom Flag 9 sofort zurückgesetzt. Das Senden von Flag 0 dektiviert die Digital Ausgang konfiguration und verhindert das erneute Einschalten durch die vorherige Sendung von Flag 9.

'''Einschalten''' erfolgt grundsätzlich mit einer minimum Verzögerung von 1 Minute. Der Startzustand ist Flag 0 und die Einschaltung erfolgt einfach mit Flag 9 (nach 1 Minute).

Umgesetzt habe ich das ganze in FHEM mit dem HTTPMOD Modul. Hier gibt es nun einen SET Aufruf, der das Flag inklusieve aller Konfigurations Parameter (siehe oben das json) übermittelt. Anschließend wird ein GET für diesen Aufruf gemacht, der den Status im FHEM aktualisiert.

Die sleep 1 sind hierbei nicht erforderlich, da die Kommunikation selber bereits syncronisiert ist und es sich beim Test gezeigt hat, das diese Verzögerung durch das GET ausreicht.

Generell ist natürlich nochmals zu erwähnen, dass es leider nicht möglich ist den Relais Status abzufragen. Die einzige Prüfung, die eventuell noch etwas mehr Sicherheit geben könnte wäre eine Nachverfolgung des Flags in einer Art Schrittschaltung. Hierbei könnte man wie oben erwähnt nach dem Senden des Flags eine direkte Abfrage anhängen und anschließend das nächste Flag senden und wieder abfragen.

Beispiel der Schaltreihenfolge:

9-0 => Aus, das Flag bleibt nun auf 0
9 => Ein nach 1 Minute
9-0 => Aus, das Flag bleibt nun auf 0

Durch die 9 schaltet es bereits ab, würde jedoch nach 1 Minute wieder an gehen.
Die 0 deaktiviert die Steuerung komplett.

Ich denke durch diese Vorgehensweise kann man auch die anderen Schaltkonfigurationen im Wechsel verwenden. Die Abschaltung sollte dann jeweils durch die Wiederholung der aktuell aktiven Konfiguration gefolgt vom Flag 0 erfolgen.

Anschließend kann dann die neu gewüschte Konfiguration folgen.

Somit wäre das Flag 0 dann auch das Signal für ein auf jeden Fall abgeschaltetes Relais.

======RAW Definition des WR_2_API Slave ab v1.16======
Auch hier kann man im Schwarm für den zweiten Wechselrichter eine verkürzte definition verwenden.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_2_API.txt Beispiel WR_2_API]

===Batteriesteuerung über den Plenticore===
Beim Plenticore ist der Speicher an einem der Stringanschlüsse angeschlossen und die Steuerung obliegt direkt dem Wechselrichter. Aus diesem Grund ist eine Beeinflussung des Speicherverhaltens auch nur über den Wechselrichter möglich. Hierzu gibt es ab der Plenticore Version v1.16 zwei mögliche Schnittstellen. Die bisherige API Schnittstelle und auch die ModBus Schnittstelle, die nun auch das Setzen von Registern ermöglicht.
In der bisherigen Implementierung in FHEM wird die API Schnittstelle verwendet, da hierüber auch einzelne Funktionalitäten für den Betreiber möglich sind, die auch ohne die Freischaltung der Externen Speichersteuerung möglich sind. Tiefergehende Steuerungen bedürfen der Freischaltung durch den Installateur.

Die bisherige Steuerung des Speichers war im PV_Schedule Device implementiert, was sich jedoch als recht unübersichtlich erwiesen hat. Aktuell wurde ein weiteres DOIF Device eingerichtet, das nun die umfangreichere Bedienung der externen Speichersteuerung übernommen hat. Die Konfiguration wurde ebenfalls wieder in einem DUMMY abgebildet.

====Batteriesteuerung Möglichkeiten====
=====Speicher Basissteuerung=====
Einige Speichersteuerungen werden als Grundlegend angesehen und sind deshalb immer aktiv. Diese Funktionalität ist auch ohne die externe Speichersteuerung für den Betreiber möglich.
<pre>
- smart_laden (bei geringer Leistung im Herbst/Winter)
- MinSOC Sommer/Winter Umschaltung
</pre>
======smart_laden und laden_beendet======
<pre>
Die Steuerung von MinSOC und MinHomeConsumtion ist über das device WR_1_API auch für den Anlagenbetreiber möglich.
Bei einem schlechten Forecast, z.B. im Herbst/Winter, wurde ein Vorschlag aus dem Photovoltaikform umgesetzt.
Die Batterie wurde bisher am Tag immer kurz geladen, dann wieder durch z.B. eine Wärmepumpe geleert und das immer im Wechsel.
Da im Winter ja eh Strom zugekauft werden muss wird nun die Batterie einfach stetig mit dem Überschuss, der nicht sofort verbrauchen kann, geladen.
Dieser Vorgang wurde als smart_laden und laden_beendet implementiert. Nun ist Ruhe eingekehrt :-),

Laut dem EFT Service ist es zwar kein Problem die Batterie einfach immer wieder kurz zu laden und sofort wieder zu entladen, doch die jetzige Variante sieht etwas schonender aus.
Das könnte sich dann in längerer Lebenszeit bemerkbar machen, was man aber erst in 10 Jahren behaupten könnte :-)
</pre>
'''Umsetzung:'''
<pre>
Bei MinSOC 15% wird MinHomeConsumtion auf den Wert Battery_Info_WorkCapacity gesetzt und die Batterie kann schön den ganzen Tag laden, oder im Forum vorgeschlagen bis SOC 90% .
Dadurch, dass MinHomeConsumtion auf die Maximalleistung gesetzt wurde würde die Batterie erst bei diesem Wert entladen dürfen, was eher unwahrscheinlich ist. Wichtig ist nur, dass der gesetzte Wert höher ist, als der zu erwartende Maximalverbrauch des Hauses. Setzt man MinHomeConsumtion auf einen Wert, der den Verbrauch eines Großverbrauchers im Haus nahe kommt, dann würde nur dieser unterstützt. Das nur als Randbemerkung.
</pre>
'''Nebeneffekte:'''
<pre>
- Das Laden der Batterie kann somit auch mal Tage dauern, wenn zu wenig PV Leistung vom Dach kommt.
- Es wird vermutet, dass der MinSoC Wert bei geringer Leistung in der Batterie ungenau wird,
aber bei Ladung bis 100% exakter berechnet wird. MinSoC ist keine exakte Wissenschaft.
- Stellt der Kontroller der Batterie fest, das die Leistung in der Batterie einen Grenzwert unterschritten hat,
wird der MinSoC korrigiert und es kommt zu dem Effekt, das mitten in der Nacht der MinSoC auf einmal
nach unten fällt. Damit wird dem Wechselrichter signalisiert, das nachgeladen werden muss, um MinSoC
wieder zu erreichen. Das Resultat ist die bekannte Notladung in der Nacht aus dem Netz.
</pre>

======MinSOC Sommer/Winter Umschaltung======
Dies gehört zur Basissteuerung und schaltet den MinSOC von Sommer auf Winterbetrieb, um eine Notladung aus dem Netz zu vermeiden.
<pre>
Aktivierung: Ist immer aktiv
Aktivität : Im Speicher wird MinSOC verändert

Konfiguration:
Die MinSOC Werte wurden vom Hersteller empfohlen
SpeicherMinSOC_Sommer 5
SpeicherMinSOC_Winter 20

Der nächste Schwellwert sollte so gewählt werden, ab welcher Forecast Leistung der Speicher noch genügend nachgeladen wird, sodass es keine Notladung in der Nacht gibt. Es ist normal, dass der Speicher hierbei nicht den Bedarf der Nacht decken kann (Herbst/Winter). Das Nachladen sollte jedoch für die Deckung des Eigenverbrauchs vom Plenticore reichen.

SpeicherMinSOC_fc1_Limit 13000
</pre>
=====Zeit Steuerung eines Lade-/Entladefensters (Tarifsteuerung)=====
Für diejenigen, die einen Zeittarif ihres EVU haben, ermöglicht dies ein Zeitfenster zu definieren, in dem der Speicher z.B. bei einem hohen Tarif entladen werden darf. Außerhalb dieser Zeit wird dann das Entladen gesperrt, damit der günstige Tarif genutzt werden kann.
'''Achtung, in der Schweiz ist es verboten den Speicher aus dem Netz zu laden'''

Für die Verwendung der DOIF Zeitsteuerung ist hier [https://fhem.de/commandref_DE.html#DOIF_Zeitsteuerung DOIF_Zeitsteuerung] eine sehr gute Beschreibung zu finden.

======Aktivierung über WR_1_Speicher_1_ExternControl======
Um die Zeitsteuerung zu verwenden werden im WR_1_Speicher_1_ExternControl Device folgende readings gesetzt.
<pre>
SpeicherEntladung:Automatik,Zeit,SpeicherTrigger
Automatik - Der Speicher wird vom Wechselrichter gesteuert, oder über die eigene ExternControl der API
Zeit - Das Laden und Entladen wird mit den Zeitwerten beeinflusst
SpeicherTrigger - beeinflusst das Laden und Entladen direkt ohne die Zeitsteuerung

SpeicherZeitEnde/SpeicherZeitEnde
Die Zeitangaben können manuell fest gesetzt werden, oder über zusätzliche Timer täglich neu überschrieben werden.
Eine gültige Zeit und entsprechendes Timeing obliegt dem Anwender.

Zwischen Start und Ende wird der Speicher zum Entladen freigegeben und zwischen Ende und Start gesperrt.
</pre>
<pre>
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 00:00
</pre>
Um ein flexibles Zeitfenster zu nutzen, ist es möglich die Zeiten z.B. durch ein DOIF oder einen WeekdayTimer dynamisch zu verändern. Hierbei liegt die logische Kontrolle beim Anwender, der für plausible Änderungen zuständig ist.

======PV_1_EVU_Tarif_1 WeekdayTimer (Beispiel)======
Es gibt hierbei zwei Möglichkeiten, eine Zeitsteuerung umzusetzen, die etwas unterschiedliche Verhaltensweisen ermöglichen.
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_1 WeekdayTimer WR_1_Speicher_1_ExternControl de 12345|00:01|Arbeitstage {fhem("setreading $NAME SpeicherZeitStart 07:00");; fhem("setreading $NAME SpeicherZeitEnde 16:00");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_1 DbLogExclude .*
attr PV_1_EVU_Tarif_1 alias PV_1_EVU_Tarif_1
attr PV_1_EVU_Tarif_1 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_1 disable 0
attr PV_1_EVU_Tarif_1 group PV Steuerung EVU
attr PV_1_EVU_Tarif_1 icon clock
attr PV_1_EVU_Tarif_1 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_1 sortby 112
attr PV_1_EVU_Tarif_1 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>
======PV_1_EVU_Tarif_2 WeekdayTimer (Beispiel)======
'''Nutzung von "SpeicherEntladung Zeit":'''
<syntaxhighlight lang="Perl">
defmod PV_1_EVU_Tarif_2 WeekdayTimer WR_1_Speicher_1_ExternControl de 60|00:01|Wochenende {fhem("setreading $NAME SpeicherZeitStart 00:00");; fhem("setreading $NAME SpeicherZeitEnde 23:59");; fhem("setreading $NAME SpeicherEntladung Zeit")}
attr PV_1_EVU_Tarif_2 DbLogExclude .*
attr PV_1_EVU_Tarif_2 alias PV_1_EVU_Tarif_2
attr PV_1_EVU_Tarif_2 commandTemplate set $NAME $EVENT
attr PV_1_EVU_Tarif_2 disable 0
attr PV_1_EVU_Tarif_2 group PV Steuerung EVU
attr PV_1_EVU_Tarif_2 icon clock
attr PV_1_EVU_Tarif_2 room Strom->Photovoltaik
attr PV_1_EVU_Tarif_2 sortby 113
attr PV_1_EVU_Tarif_2 stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======WR_1_Speicher_1_Zeiten WeekdayTimer (Beispiel)======
In diesem Beispiel wird der frei verwendbare Trigger für die Zeitsteuerung verwendet. Hierbei muss jeder Wechsel zwischen entladen und gesperrt über das reading "SpeicherTrigger [entladen|gesperrt]" gesteuert werden. Ein zurückfallen in ein Zeitfenster ist nicht möglich.
'''Nutzung von "SpeicherEntladung Trigger":'''
<syntaxhighlight lang="Perl">
defmod WR_1_Speicher_1_Zeiten WeekdayTimer SpeicherZeiten de 12345|07:00|entladen 12345|16:00|gesperrt 60|00:00|entladen 60|23:59|gesperrt {fhem("setreading $NAME SpeicherTrigger $EVENT")}
attr WR_1_Speicher_1_Zeiten DbLogExclude .*
attr WR_1_Speicher_1_Zeiten alias WR_1_Speicher_1_Zeiten
attr WR_1_Speicher_1_Zeiten commandTemplate set $NAME $EVENT
attr WR_1_Speicher_1_Zeiten disable 0
attr WR_1_Speicher_1_Zeiten group PV Steuerung EVU
attr WR_1_Speicher_1_Zeiten icon clock
attr WR_1_Speicher_1_Zeiten room Strom->Photovoltaik
attr WR_1_Speicher_1_Zeiten sortby 111
attr WR_1_Speicher_1_Zeiten stateFormat {sprintf("geplant: %s %s", ReadingsVal($name,"nextUpdate","?"), ReadingsVal($name,"nextValue","?"))}
</syntaxhighlight>

======Tarifsteuerung mit einem DOIF (Beispiel)======
<syntaxhighlight lang="Perl">
################################################################################################################
## 1 Setzen des niedrig Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 07:00 - 19:00 Uhr den Speicher zum Entladen
([07:00|8])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 19:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 2 Setzen des hohen Tarifs. Das WR_1_Speicher_1_ExternControl DOIF reagiert dann auf das Zeitfenster und
## aktiviert von 00:00 - 23:59 Uhr den Speicher zum Entladen
DOELSEIF
([00:00|7])

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 00:00)
(setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 23:59)
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit)

################################################################################################################
## 3 Hier könnte dann die Berechnung der überschüssigen Zeit rein, wenn Du mit 40% aus der Nacht kommen würdest
DOELSEIF
(*** )

(setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart [neu berechnete SpeicherZeitStart])
(setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit) ## Triggert den ersten Event, damit die Zeit sofort aktiv wird.
</syntaxhighlight>

======Speicherentladung mit Zeit und Trigger (Beispiel)======
Dies ist ein spezielles Beispiel, bei dem die Nutzung von "SpeicherEntladung Zeit" mit "SpeicherEntladung SpeicherTrigger" gemeinsam verwendet wird.
Die Basis ist wie oben beschrieben die Tarifsteuerung mit "SpeicherEntladung Zeit" dies wird durch einen oder mehrere WeekdayTimer mit Zeiten eingestellt. Nach dem setzen einer Zeit wird dies mit "fhem("set $NAME SpeicherEntladung Zeit")" aktiviert. Soll nun innerhalb des entlade Fensters der Speicher gesperrt werden, so kann man den SpeicherTrigger auf gesperrt setzen und dies dann mit "fhem("set $NAME SpeicherEntladung SpeicherTrigger")" aktivieren. Später lässt sich das dann wieder deaktivieren und die Zeitsteuerung läuft wieder weiter.
<pre>
1.) Durch einen Timer wird folgendes täglich um 00:01 Uhr gesetzt
setreading WR_1_Speicher_1_ExternControl SpeicherZeitStart 07:00"
setreading WR_1_Speicher_1_ExternControl SpeicherZeitEnde 16:00"
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Vor 07:00 Uhr ist der Speicher gesperrt, zwischen 07:00 und 16:00 Uhr geht er auf entladen, danach wieder auf gesperrt.

2.) Mit einem Trigger wird der Speicher in der definierten entlade Zeit für kurze Zeit gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherTrigger gesperrt
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung SpeicherTrigger
Dadurch wird der Speicher zu einem beliebigen Zeitpunkt auf gesperrt gesetzt, egal wie die Situation der Zeit Steuerung ist.

3.) Rückfall zur vorher eingetragenen Zeit Steuerung
setreading WR_1_Speicher_1_ExternControl SpeicherEntladung Zeit
Der SpeicherTrigger wird abgeschaltet und die zeit Steuerung wieder aktiviert. Es gelten die zuvor eingetragenen Zeiten und der Speicher geht je nach Zeitfenster auf entladen oder gesperrt.

'''Wichtig ist hierbei, dass man den gewünschten Zustand zuerst setzt, bevor man die jeweilige Steuerung aktiviert.''' Ansonsten treten kurze Zustandswechsel auf, die vermieden werden können.
</pre>

=====Externe Speichersteuerung (ExternControl)=====
'''Für die erweiterte Steuerung muss die externe Speichersteuerung des Plenticore aktiviert werden.'''

======Externe Speichersteuerung Ladekontrolle======
Dies ist eine kurz Beschreibung für einen kompletten Ladezyklusablauf
<pre>
- Morgens wird geprüft, wie gut der Haushalt durch die Nacht gekommen und wie hoch der MinSOC noch ist
- Reserve ist 3x MinSOC, also im Sommer 15% und im Winter 60% (im Winter ist der Speicher eh morgens leer :-) )
- Dann wird ein MaxSOC für den Tag berechnet
- Bis zum Reserve SOC wir morgens sofort geladen
- Danach wird einstellbar mit geringer Leistung am Vormittag bis SOC 30% geladen
- Innerhalb des Mittagshoch, so meistens dynamisch in der Zeit von 10:00 - 16:00 Uhr
wird mit berechneter Leistung bis zum MaxSOC geladen
- Man kann auch eine feste Ladeleistung für das Mittagshoch angeben
- Am Nachmittag wird der MaxSOC dann weiter gehalten
- Wird der Speicher am Nachmittag, wegen schlechtem Wetter verwendet, wird der MaxSOC auf 100% angehoben
- Bei erreichen von SOC 100% wird eine Begrenzung auf MaxSOC 95% durchgeführt, damit nicht ständig nachgeladen wird
- Spätestens am Abend wird nochmals der MaxSOC von diesem Tag gemerkt, der Zeitpunkt variiert mit der Jahreszeit
- Nach ungefähr einer Woche gibt es, wegen des im Speicher berechneten SOC, morgens einen schnellen Abfall
der Entladeleistung. Dadurch fällt der SOC dann so niedrig, dass die Steuerung an diesem Tag auf 100% auflädt,
wodurch der Speicher dann intern den SOC wieder richtig berechnet

Und schon geht das Spiel von vorne los.
</pre>

======MaxSOC Kontrolle======
Es wird versucht, den Speicher am Abend nicht zu 100% zu laden, aber morgens noch mit 3* MinSOC aus der Nacht zu kommen.
<pre>
Aktivierung: SpeicherMaxSOCControlActive An
Aktivität : SpeicherMaxSOCControlRunning Aus = momentan keine Steuerung
SpeicherMaxSOC_Actual 100 <<< wird berechnet, kann jedoch für diesen Tag anschließend überschrieben werden
SpeicherMaxSOC_DayBefore 100 <<< wird berechnet und dient als Merker

Konfiguration:
Dieser Wert muss auf die Anlage angepasst werden und dient als Schwellwert. Die Leistungsangabe soll so hoch sein, dass der Speicher, bei diesem Forecast, auf jeden Fall mit einer Überschussleistung von 3* MinSOC aus der Nacht kommt. Im Frühjahr ist dies besonders gut abzuschätzen, sobald eine Wärmepumpe nachts nicht mehr heizt und nur noch die Grundversorgung in der Nacht aus dem Speicher gedeckt werden muss.
Durch die Abfrage des Forecasts von morgen ist hierbei berücksichtigt, dass bei einer schlechten Prognose die Speicherladung nicht limitiert wird, was auch im Sommer mal der Fall sein kann.

SpeicherMaxSOC_fc1_Limit 30000
</pre>

======Middayhigh Kontrolle======
Über die KI_Prognose() Funktion wird ein Middayhigh ermittelt, wenn der WR nur 70% einspeisen darf. Auch beim Betrieb von zwei Wechselrichtern ist dies wichtig, da mit Stand 03/2021, der Plenticore den Hausverbrauch nicht korrekt ermitteln kann. In diesem Fall funktioniert die "intelligente Batteriesteuerung" nicht mehr und muss deaktiviert werden. Durch die Middayhigh Kontrolle wird aus dem Forecast, durch die Funktion KI_Prognose() eine Überschreitung von Inverer_Max_Power (70%) Regelung ermittelt. Damit kann über die externe Speichersteuerung die Hauptladung des Speichers in die Mittagszeit verlagert werden, um die dynamische 70% Regelung zu nutzen, bevor der Wechselrichter abgeregelt wird.
Die KI_Prognose Werte werden in dem WR_ctl Device abgelegt und sind dort als Yield_fc* zu finden.
<pre>
Aktivierung: SpeicherMiddayControlActive An
Aktivität : SpeicherMiddayControlRunning Aus <<<< momentan keine Steuerung
WR_ctl:Yield_fc0_middayhigh 0 <<<< Es gibt kein Mittags Hoch. Wird aus KI_Prognose() gesetzt
WR_ctl:Yield_fc0_middayhigh_start 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet
WR_ctl:Yield_fc0_middayhigh_stop 00:00 <<<< wird aus dem Forecast in KI_Prognose() berechnet

Konfiguration:
Der Wert von SpeicherMidday_MaxChargePowerAbs sollte so gewählt werden, dass der Speicher am Vormittag langsam und gleichmäßig bis auf SpeicherMidday_MaxSOC geladen wird.
Ab der WR_ctl:Yield_fc0_middayhigh_start wird dann unlimitiert bis zur WR_ctl:Yield_fc0_middayhigh_stop in der Mittagszeit weiter geladen. Wenn SpeicherMaxSOCControlActive auf 1 ist, wird hierbei weiterhin das Laden limitiert.

SpeicherMidday_Inverter_Max_Power 8500 <<<< hier kann man manuell einen Wert festlegen, wenn es keine 70% Regelung gibt
SpeicherMidday_MaxChargePowerAbs_midday 1000 <<<< hängt vom Speicher ab; Wird der wert auf 0 gesetzt, so erfolgt eine dynamische Berechnung zur Laufzeit
SpeicherMidday_MaxChargePowerAbs_morning 450 <<<< hängt vom Speicher ab
SpeicherMidday_MaxSOC 30 <<<< Es soll nur bis dahin geladen werden, damit Mittags genug Platz ist
</pre>

====RAW Definition des WR_1_Speicher_1_ExternControl====
Achtung, es wurde eine Sperre beim Betrieb einer WallBox eingebaut, die natürlich jeder für sich anpassen, oder gegebenenfalls entfernen muss.
<pre>
- Block 2_smart_Laden_start_WB_1
- Block 3_smart_Laden_beenden_WB_1
- Im Block 3_smart_Laden_beenden_Automatik ist eine zusätzliche Bedingung
and\
[$SELF:WB_1_smart_laden_before] eq "---" ## Es wird gerade kein Fahrzeug geladen\
- setstate WR_1_Speicher_1_ExternControl WB_1_smart_laden_before ---
</pre>

Der Ladezustand wird hierbei von der WallBox abgefragt und unterscheidet sich bei verschiedenen Herstellern:
Hier bitte gerne noch weitere WallBoxen bei mir melden.
<pre>
openWB:
[WB_1:lp_1_ChargeStat] eq "loading"

go-eCharger:
[WB_1:car_state] eq "2" ## Ladevorgang läuft
</pre>

Das DOIF übernimmt die Externe Speichersteuerung.
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_1_Speicher_1_ExternControl.txt Beispiel WR_1_Speicher_1_ExternControl]

===Kostal Smart Energy Manager (KSEM) (Modbus/TCP)===
Sollte man mehrere AC Quellen im Haus haben werden die Messwerte benötigt, um den Hausverbrauch richtig zu berechnen.

Um den ModBus am KSEM zu nutzen muss man im ModBus Menü die Option "Slave" aktivieren.

Auch hier ist ein Interval von 60 Sekunden gesetzt worden. Das Logging ist auf Active_energy.* eingeschränkt, weshalb man seine zusätzlichen Werte noch selber definieren muss.

==== RAW Definition des KSEM ====
Zun Thema KSEM bestand direkter Kontakt mit dem Kostal Service. Der KSEM ermittelt nicht alle Werte, welche in der SunSpec spezifiziert sind. Alle nicht unterstützen Werte sind in den Registern mit 0x8000 gekennzeichnet. Für die nicht unterstützten Zählerstände wird 0x800000000 ausgegeben.
Der Summenstrom M_AC_Current (sum of active phases) kann aber durch den Endanwender selber aus der Summe der Einzelwerte (Phase A AC current, Phase B AC current Phase C AC current) berechnet werden. Die einzelnen Spannungen zwischen den Phasen können nicht gemessen werden und werden deshalb nicht ausgegeben.

Das Device wurde umbenannt, um es besser in die gesamt Implementierung einzugliedern.
<pre>
- WR , es wird vom Wechselrichter benötigt und sortiert sich im FHEM Web auch dort ein.
- 0 , es wird von mehreren Geräten benötig, was z.B. auch eine Wallbox sein kann. WR_[1|2] könnte bedeuten, dass es nur von diesem Gerät benötigt wird.
</pre>
Bei einer Schwarm Installation steuert der KSEM mehrere Wechselrichter bezüglich der 70% Regelung. Eine Wallbox benötigt ebenfalls eine Verbindung, wenn nur mit Überschuss geladen werden soll.
Auch wenn der KSEM im FHEM auf disable 1 steht ist er aktiv und steuert die Wechselrichter und Wallboxen. Es bedeutet nur, dass die Werte nicht zusätzlich im Fhem eingelesen werden. Der Plenticore bereitet die Daten bereits selber auf und liefert diese im WR_1 Device per ModBus bereits mit.
Da es beim Plenticore ein Problem mit den Statistiken im Schwarm gibt wird das Device WR_0_KSEM nun aktiv verwendet. Durch das Device PV_Schedule werden die Werte Active_energy[+|-] ins Device WR_1_API übertragen und bilden die initial Werte für die Day/Month/Year Statistiken.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_0_KSEM.txt Beispiel WR_0_KSEM]

==Device Übersicht mit Hilfen zur Orientierung==
<pre>
Device über Device Hardware Protokoll Netzwerk Informationen

WR_0_KSEM WR_1 KSEM MODBUS LAN Messwerte vom Netzanschlusspunkt
WR_1 rs485 4 Draht zum WR Notwendig, wenn ein Speicher am Plenticore betrieben wird

WR_1 Plenticore MODBUS LAN Messwerte und berechnete Werte, teilweise Speicher Informationen
WR_1_API HTTPMOD LAN Statistiken, Speichersteuerung und Informationen

WR_2 Plenticore MODBUS LAN Messwerte und berechnete Werte. Achtung, im Schwarm hat nur der Master WR einen Speicher.
WR_2_API HTTPMOD LAN Statistiken

FHEM Steuerung MODBUS LAN Laufende Informationen im Minuten Takt
HTTPMOD LAN Abfragen und Steuerung einzelner Devices

WR_ctl DOIF Startet regelmäßige Aktionen zur zeitlichen Steuerung der PV-Anlage
Dient der Anzeige von aktuellen und Statistischen Daten

1 Stündlich
1.1 WR_2_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen; die Reihenfolge ist auch wichtig!
1.2 WR_1_API 20_Statistic_EnergyFlow Statistiken vom Plenticore abholen

2 Stündlich von 05:00 bis 22:00
2.1 KI_Prognose() für fc0 und fc1 Aktualisieren der fc0 Prognose

3 kurz nach Mitternacht
3.1 4_WR_1_API_init_Werte Lesen und eventuell korrigieren der init Werte

WR_1_Speicher_1_ExternControl DOIF Externe Speichersteuerung

1 Stündlich

1.1 WR_1_API 21_Battery_Information Allgemeine Informationen
Battery_Info_SoC,
Battery_Info_WorkCapacity
1.2 WR_1_API 22_Battery_InternControl Speicher Information der Internen Steuerung
Battery_InternControl_MinSoc,
Battery_InternControl_MinHomeConsumption
1.3 WR_1_API 23_Battery_ExternControl Speicher Information der Externen Steuerung
1.4 WR_1_API 25_Battery_EM_State Speicher Status z.B. "Normal"

2 Unterschreitung des MinSOC im Winter
2.1 smart_laden PV Überschuss wird in Batterie geladen. Keine Entladung
2.2 WR_1_Speicher_1_ExternControl ExternTrigger gesperrt Batterie ExternTrigger, Entlademodus gesperrt . Die Zeit Steuerung wird verriegelt

3 Freigabe zur Entladung im Winter
3.1 bei überschreiten von SOC 90% Sobald der Speicher gut gefüllt ist oder
WR_1_API:Battery_Info_SoC
3.2 Bei Zeitsteuerung und guter Prognose mit SOC 40% bereits vorher, weil der Tarif teuer ist

4 Speicher Freigabe bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

5 Speicher sperren bei Trigger oder Zeit Steuerung Dieses cmd_ löst die Abhängigkeiten von Zeit und Trigger auf

6 Wiederhole alle 180s die Kommandos der ExternControl Steuerung Wenn keine Wiederholung erfolgt geht der Plenticore wieder auf die interne Steuerung
6.1 WR_1_Speicher_1_ExternControl:SpeicherMiddayControlActive wird durchlaufen, wenn der Forecast eine z.B. 70% Überschreitung erkannt hat und
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxSOC begrenzt dann morgens den MaxSOC
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_midday und den MaxChargePowerAbs
WR_1_Speicher_1_ExternControl:SpeicherMidday_MaxChargePowerAbs_morning für morgens und mittags
6.2 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Wenn morgens der Speicher zu voll war, wird der MaxSOC bis abends begrenzt
6.3 WR_ctl:Yield_fc0_middayhigh_start <> WR_ctl:Yield_fc0_middayhigh_stop Das Laden wird mit voller Leistung freigegeben
6.4 nach Ablauf von WR_ctl:Yield_fc0_middayhigh_stop Die Midday Steuerung wird abgeschaltet, es wird normal weiter geladen, bis MaxSOC erreicht ist
6.5 WR_1_Speicher_1_ExternControl:SpeicherMaxSOC Batterie MaxSOC halten, der Default ist 100%

7 Initialisierung der externen Speichersteuerung
7.1 Ist morgens der Speicher zu voll Wenn der Speicher morgens voller als 3x MinSOC ist wird MaxSOC gesetzt
7.2 Wenn eine Überschreitung der 70% erwartet wird Aktivierung der Midday Steuerung

8 Zurücksetzen der externen Speichersteuerung

9 Umschaltung des MinSOC wenn zu wenig Leistung erwartet wird Schaltet im Herbst/Winter den MinSOC auf 20%

10 Umschaltung des MinSoc wenn viel Leistung erwartet wir Setzt den MinSOC wieder im Frühling/Sommer auf 5%

11 WR_1_Speicher_1 Status aktualisieren Nur beim BYD HV, Abfrage der Speicher Detailinformationen. Kann einfach entfernt werden

WR_1_Speicher_1_ExternControl readings Konfiguration für die externe Speichersteuerung

ExternTrigger none Wird automatisch gesetzt und dient der Verriegelung im WR_1_Speicher_1_ExternControl
Zustände: frei/gesperrt/none
SpeicherCmdRepeatActive [An|Aus] An/Aus Trigger für WR_1_Speicher_1_ExternControl, aktiviert die Kommandowiederholung
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherEntladung Steuert den Modus der externen Speichersteuerung
Zustände:
Automatik - MinSOC Steuerung Sommer/Winter
Zeit - z.B. bei Tarifsteuerung. Zeiten werden über zusätzliche DOIF
oder WeekdayTimer gesetzt
Trigger - Ein beliebiger Mechanismus z.B. DOIF steuert den Speicher

SpeicherMaxSOCControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMaxSOCControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMaxSOC_Actual 100 Wird im WR_1_Speicher_1_ExternControl cmd_7 berechnet, wenn der Speicher morgens zuviel Ladung hat
SpeicherMaxSOC_DayBefore xx Das ist der letzte berechnete Wert, damit sich die Berechnung langsam einem Optimum nähern kann
SpeicherMaxSOC_fc1_Limit 30000 Hier einen Wert setzen, bei dem der Speicher über Nacht bis morgens gereicht hat.
Damit wird dann der Übergang vom Winter zum Frühjahr erkannt.
SpeicherMiddayControlActive [An|Aus] Wird von KI_Prognose() gesetzt, wenn der fc0 über WR_1:Inverter_Max_Power (70% Regel) liegt
SpeicherMiddayControlRunning [An|Aus] Das reading signalisiert den aktuellen Laufzeitstatus
SpeicherMidday_Inverter_Max_Power 8500 Manuelles überschreiben für WR_1:Inverter_Max_Power, wenn man kontrollierter den Tag über laden möchte
SpeicherMidday_MaxChargePowerAbs_midday 1000 Begrenzung der Ladeleistung am Mittag, damit nicht zu schnell geladen wird.
Steht der Wert auf 0 wird dynamisch während der Laufzeit ein Wert berechnet.
SpeicherMidday_MaxChargePowerAbs_morning 450 Begrenzung der Ladeleistung am Vormittag, damit Mittags genug Platz im Speicher ist
SpeicherMidday_MaxSOC 30 Limitierung des Speichers um Mittags genug Platz zu haben
SpeicherMinSOC_Sommer 5 Sommer MinSOC von Kostal vorgegeben
SpeicherMinSOC_Winter 20 Winter MinSOC von Kostal vorgegeben
SpeicherMinSOC_fc1_Limit 14000 Wenn im Herbst/Winter der Forecast zu schlecht wird muss dieser Wert auf die Anlage
angepasst werden. Das signalisiert die Winter Zeit
SpeicherTrigger none entladen/gesperrt/none wird über WR_1_Speicher_1_ExternControl gesetzt
SpeicherZeitEnde 16:00 Die Zeiten geben das Entlade Fenster an und werden durch weitere DOIF oder WeekdayTimer gesetzt
SpeicherZeitStart 07:00 Dies kann zur Tarifsteuerung verwendet werden, oder um ein Entladung zeitlich zu verschieben
Das Zeitfenster kann durch den MinSOC Schutz im Winter veriegelt sein.

Beispiele:

1 SpeicherEntladung Automatik
Nur grundlegende Steuerungen erfolgen automatisch.
- Sommer/Winter Umschaltung des MinSOC Schützt den Speicher vor einer Notladung im Winter
- smart_laden Sorgt dafür, das der Speicher im Winter nicht ständig geladen und wieder entladen wird
- laden_beendet Gibt den Speicher nach dem smart_laden wieder frei

2 SpeicherEntladung Zeit
Zeitsteuerung für laden/entladen
- WR_1_Speicher_1_ExternControl:SpeicherZeitEnde/SpeicherZeitStart Die Start/Ende Zeiten müssen gesetzt werden, dies muss über weitere DOIF oder WeekdayTimer erfolgen.
- Sommer/Winter Umschaltung des MinSOC
- smart_laden
- laden_beendet
</pre>

==Wenn man mal etwas umbenennen möchte==
Es kommt immer wieder vor, dass man ein Device oder den Namen eines readings umbenennen möchte. Dies hat natürlich Auswirkungen auf andere Devices und auch auf die bisherigen Daten in der DbLog. Hier sollen dann jetzt Hilfestellungen gesammelt werden.
===Allgemeine Hilfestellungen===
'''Es sollte immer vorher eine Datensicherung gemacht werden!'''<pre>
Den Device Namen ändert man am Besten mit einem "rename".
Damit nichts vergessen wird ruft man den RAW Editor auf und kann dann mit der Suchfunktion des Browsers nach dem zu ändernden Text suchen.
Wenn alle Devices im ersten Durchlauf geändert wurden und man meint man wäre fertig, dann durchsucht man am besten nochmal die fhem.cfg . Sollten dort noch alte Namen vorhanden sein, kann man erkennen in welchem Device das ist und dieses dann in der Fhem Oberfläche korrigieren.
</pre>
'''Bitte nicht in der fhem.cfg Änderungen vornehmen! Dort nur zur Kontrolle suchen.'''

===Ein Device umbenennen===
<pre>
Das ist schnell gemacht, indem man in der Fhem commandline ein "rename <Device> <neues Device>" macht.
Es ist auch möglich das alte Device mit "disable 1" zu deaktivieren und dann einfach ein komplett neues z.B. aus dem Wiki zu definieren.
Das alte Device kann dann später gelöscht werden, sobald das neu richtig läuft. In der datenbank kann man die alten Werte dann auch wieder dem neuen Device zuordnen.
Als nächstes haben viele Devices noch ein Attribut "alias", das meistens den selben Namen wie das Device beinhaltet.
Ein Device Name kann auch in anderen Attributen als Variable verwendet worden sein. Das ist zu prüfen.
Nun werden alle neuen, aktualisierten readings unter dem neuen Device Namen in die Datenbank geschrieben.
Die bisherigen Log Einträge müssen nun noch dem neuen Device zugeordnet werden.
</pre>
===Ein reading umbenennen===
<pre>
Dies geschieht innerhalb des Devices, indem man das Attribut, dass das reading erzeugt ändert und den neuen Namen einträgt.
Bei der nächsten Aktualisierung erscheint dann ein zweites reading mit dem neuen Namen.
Der neue Name muss dann noch an allen Stellen innerhalb des Devices eingetragen werden, Das kann im userReading, stateFormat oder auch in anderen Attributen der Fall sein.
Soll dieses Reading gelogged werden, ist "DbLogInclude" zu prüfen. Der alte Name kann raus und der neue muss rein, oder die RegEx muss geändert werden.
Zum Schluss muss das alte reading noch entfernt werden, was mit "deletereading <Device> <alter reading Name>" erfolgen kann. Oft ist hier auch eine RegEx möglich.
</pre>

===DbLog aufräumen===
Als kleine Vorabinformation möchte ich geben, dass es hierbei eventuell zu '''duplicate keys''' kommen kann. Dies rührt daher, dass eventuell der alte und der neue Namen parallel geloggt wurde. Schaut Euch hier die Daten an, welche Ihr behalten möchtet, oder ob Ihr wirklich z.B. das alte reading und SW_* braucht. Ab dem Zeitpunkt wo es parallel gelaufen ist, wäre dann eins (das alte) zu löschen.

Beim Übergang zum Schwarm habe ich alle älteren Daten den neuen readings zugeordnet und momentan, ab diesem Zeitpunkt, beides gelogged.

====An der Datenbank anmelden====
Dies kann man z.B. aus einer Terminal Session heraus machen.
<syntaxhighlight lang="Perl">
mysql -h 192.168.178.xxx --port 3306 --database fhem -u fhemuser -p
</syntaxhighlight>
====Alle Devices in der history anzeigen====
<syntaxhighlight lang="SQL">
## Alle Devices in der history Tabelle
SELECT DEVICE FROM history
GROUP BY DEVICE;
</syntaxhighlight>

====Alle readings eines Devices anzeigen====
Mit einem SELECT kann man alle bisher aufgetretenen readings eines Devices über einen definierten Zeitraum anzeigen lassen.
Der Zeitraum ist mit "1 DAY" definiert, kann aber auch auf z.B. "1 MONTH" oder "2 MONTH" gesetzt werden.
<syntaxhighlight lang="SQL">
SET @device = 'WR_1';
SELECT t1.TIMESTAMP,t1.DEVICE,t1.READING,t1.VALUE
FROM history t1
INNER JOIN
(SELECT max(TIMESTAMP) AS TIMESTAMP,DEVICE,READING
FROM history
WHERE DEVICE = @device AND
TIMESTAMP > NOW() - INTERVAL 1 DAY
GROUP BY READING) x
ON x.TIMESTAMP = t1.TIMESTAMP AND
x.DEVICE = t1.DEVICE AND
x.READING = t1.READING;
</syntaxhighlight>

====Einträge eines DEVICE einem neuen DEVICE zuordnen====
In diesem Beispiel würde das alte DEVICE PV_1 dem neuen DEVICE WR_1 zugeordnet werden.
Im Anschluss müssten dann noch READING jeweils einem eventuell neuen READING Namen zu geordnet werden.
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
DEVICE = 'PV_1'
WHERE
DEVICE = 'WR_1'
AND TIMESTAMP < '2021-01-24 17:25:15';
</syntaxhighlight>

====Ein altes READING einem neuen READING Namen zuordnen====
Sehr wichtig ist '''"TIMESTAMP = TIMESTAMP"''', da hierdurch der alte TIMESTAMP erhalten bleibt.
<syntaxhighlight lang="SQL">
UPDATE history
SET
TIMESTAMP = TIMESTAMP,
READING = 'Total_DC_PV_Energy_sumOfAllPVInputs'
WHERE
DEVICE = 'WR_1'
AND READING = 'Total_DC_PV_Energy_(sumOfAllPVInputs)'
AND TIMESTAMP < '2021-03-23 17:25:15';
</syntaxhighlight>

====Alles auf einmal====
Natürlich kann man die vorherigen UPDATE auch zusammenfassen, also DEVICE und READING in einem ändern. Das sollte aber nur machen, wer in SQL entsprechende Kenntnisse hat.
Die Umbenennung des DEVICE zum neuen DEVICE und anschließend die READING Namen ist der praktikabelste Weg.

===Grafiken korrigieren===
====Grafana====
In Grafana sind die SQL Abfragen ebenfalls zu korrigieren

===Fhem Log===
Das Fhem Log ist nach jedem größeren Änderungsschritt zu sichten, da man hier ziemlich schnell vergessene Devices oder readings erkennen kann.

==Timeing für die PV extra Funktionen==
=== RAW Definition WR_ctl (DOIF)===
Das WR_ctl Device hat die zeitliche Steuerungder PV-Anlage übernommen und dient gleichzeitig der Anzeige von aktuellen und statistischen Werten im FHEMWEB.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/Wechselrichter/RAW_WR_ctl.txt Beispiel WR_ctl]

==Energie Bilanz==
<big>Achtung, es gab eine Umstellung mit diesem Device! Die Bilanz wird nun direkt im WR_ctl Device mit uiTable angezeigt.</big>

Die Energie Bilanz soll einen kompakten Überblick über die Produktions- und Verbrauchswerte liefern. Hierbei werden die momentan Werte direkt berechnet, die restlichen Werte werden als Statistiken aus dem Gerät abgefragt. Mit DbRep Devicen kann man auch Vortag/Vormonat/Vorjahr im Wr_ctl direkt mitanzeigen lassen.
===Erstellen von zusätzlichen Werten in der Datenbank===
Hier werden Werte konsolidiert, weil z.B. der Wert PV_total_Month stetig steigt. Am Ende des Monats sind die gesamten Zwischenwerte ohne Aussagekraft und werden dann später mal gelöscht.

====RAW Definition LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week====
Dieser Wert ist die wöchentliche Einspeisung ins Netz.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
<syntaxhighlight lang="Perl">defmod LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week comment Version 2020.10.21 11:14
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffAccept 15000
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week reading Statistic_EnergyFeedInGrid_Year
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week readingNameMap Statistic_EnergyFeedInGrid_Week
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week aggregation week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week reading Statistic_EnergyHomePvSum_Year
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week readingNameMap Statistic_EnergyHomePvSum_Week
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month====
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.
Gestartet über DB_Service_Schedule am ersten des Monats.
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbRep LogDB
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month DbLogExclude .*
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month aggregation month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month allowDeletion 1
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month comment Version 2020.10.23 15:00\
Dieser Wert ist der gesamte Verbrauch aus der PV Anlage inklusive Batterie im Monat.\
Gestartet über PV_Schedule am ersten des Monats\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month device PV_1_API
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month reading Statistic_EnergyHomePvSum_Month
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month timestamp_end previous_month_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Year_diff_Week====
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Year_diff_Week DbRep LogDB
attr LogDBRep_Statistic_Yield_Year_diff_Week DbLogExclude .*
attr LogDBRep_Statistic_Yield_Year_diff_Week aggregation week
attr LogDBRep_Statistic_Yield_Year_diff_Week allowDeletion 0
attr LogDBRep_Statistic_Yield_Year_diff_Week comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage pro Woche an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Benötigt für SVG_LogDB_PV_Bilanz.
attr LogDBRep_Statistic_Yield_Year_diff_Week device PV_1_API
attr LogDBRep_Statistic_Yield_Year_diff_Week diffAccept 20000
attr LogDBRep_Statistic_Yield_Year_diff_Week reading Statistic_Yield_Year
attr LogDBRep_Statistic_Yield_Year_diff_Week readingNameMap Statistic_Yield_Week
attr LogDBRep_Statistic_Yield_Year_diff_Week room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Year_diff_Week timestamp_end previous_week_end
</syntaxhighlight>

====RAW Definition LogDBRep_Statistic_Yield_Month_max_Month====
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.
Momentan noch in keinem SVC verwendet.
<syntaxhighlight lang="Perl">
defmod LogDBRep_Statistic_Yield_Month_max_Month DbRep LogDB
attr LogDBRep_Statistic_Yield_Month_max_Month DbLogExclude .*
attr LogDBRep_Statistic_Yield_Month_max_Month aggregation month
attr LogDBRep_Statistic_Yield_Month_max_Month allowDeletion 0
attr LogDBRep_Statistic_Yield_Month_max_Month comment Version 2020.10.23 15:00\
Dieser Wert gibt den gesamten Ertrag der PV Anlage im Monat an.\
Gestartet über DB_Service_Schedule am ersten Tag der Folgewoche.\
Momentan noch in keinem SVC verwendet.
attr LogDBRep_Statistic_Yield_Month_max_Month device PV_1_API
attr LogDBRep_Statistic_Yield_Month_max_Month diffAccept 20000
attr LogDBRep_Statistic_Yield_Month_max_Month reading Statistic_Yield_Month
attr LogDBRep_Statistic_Yield_Month_max_Month room Strom->Energie,System
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_begin current_year_begin
attr LogDBRep_Statistic_Yield_Month_max_Month timestamp_end previous_month_end
</syntaxhighlight>

===Löschen von nicht mehr benötigten Werten in der Datenbank===
Hier wird endgültig aufgeräumt, alte momentan Werte werden gelöscht, wenn sie nach z.B. drei Monaten keine Relevanz mehr haben. Dafür wurden im vorherigen Abschnitt zusätzliche Werte in der Datenbank erzeugt, die in Diagrammen trotzdem noch einen Trend erkennen lassen.
Wenn eine immer größer werdende Datenbank mit steigenden Antwortzeiten nicht stört, der kann das Aufräumen auch weg lassen. Bei einer späteren Migration führt dies natürlich zu höherem Aufwand und hohen Laufzeiten.

====RAW Definition LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day reading Statistic_EnergyHomeBat_Day
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day====
Löschen aller Statistic_EnergyHomeBat_Day Werte, bis auf den maximal Wert des Tages.
Der aktuelle Tag bleibt noch erhalten.
Aufruf mit: maxValue deleteOther
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_EnergyHomePvSum_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.\
Aufruf mit: maxValue deleteOther
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day reading Statistic_EnergyHomePvSum_Day
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

====RAW Definition LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day====
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
<syntaxhighlight lang="Perl">
defmod LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbRep LogDB
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day DbLogExclude .*
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day aggregation day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day allowDeletion 1
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day comment Version 2020.10.30 18:30\
Löschen aller Statistic_TotalConsumption_Day Werte, bis auf den maximal Wert des Tages.\
Der aktuelle Tag bleibt noch erhalten.
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day device PV_1_API
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day reading Statistic_TotalConsumption_Day
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day room Strom->Energie,System
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_begin previous_month_begin
attr LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day timestamp_end current_day_end
</syntaxhighlight>

===Timing für die Datenbank Einträge===
Über dieses Scheduling werden in der Datenbank zusätzliche Wochen- und Monatseinträge gesteuert.
====RAW Definition DB_Service_Schedule====
Hier werden zusätzlich Werte in der Datenbank erzeugt.
<syntaxhighlight lang="Perl">
ddefmod DB_Service_Schedule DOIF ## Monatlich Einträge\
([01:13] and ($mday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_Yield_Month_max_Month maxValue writeToDB)\
(set LogDBRep_Statistic_previous_Month sqlCmd ckey:1) ## Bildet für verschiedene Devices die Monatsauswertung\
\
## Wöchentliche Einträge\
DOELSEIF\
([01:17] and ($wday==1))\
(set LogDBRep_Statistic_EnergyHomePvSum_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_EnergyFeedInGrid_Year_diff_Week diffValue writeToDB)\
(set LogDBRep_Statistic_Yield_Year_diff_Week diffValue writeToDB)\
\
## Wöchentliche Einträge mit löschen\
DOELSEIF\
([02:17] and ($wday==1))\
(set LogDBRep_delete_Statistic_EnergyHomeBat_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_EnergyHomePvSum_Day_max_Day maxValue deleteOther)\
(set LogDBRep_delete_Statistic_TotalConsumption_Day_max_Day maxValue deleteOther)\
\
## Tägliche Einträge\
DOELSEIF\
([01:17])\
(set LogDBRep_Statistic_previous_Day sqlCmd ckey:1) ## Bildet für verschiedene Devices die Tagesauswertung\
\
## Quartal Einträge\
DOELSEIF\
(($md eq "01-01" or $md eq "04-01" or $md eq "07-01" or $md eq "10-01") and [03:11])\
(set LogDBRep_Statistic_previous_Quarter sqlCmd ckey:1) ## Erstellt die Quartalsauswertung für WR_1\
\
## Jährliche Einträge\
DOELSEIF\
($md eq "01-01" and [08:05])\
(set LogDBRep_Statistic_previous_Year sqlCmd ckey:1) ## Bildet für verschiedene Devices die Jahresauswertung
attr DB_Service_Schedule DbLogExclude .*
attr DB_Service_Schedule comment Version 2024.01.23 17:00\
Hier werden zusätzlich Werte in der Datenbank erzeugt.
attr DB_Service_Schedule do always
attr DB_Service_Schedule room System
attr DB_Service_Schedule wait 0,3:0,5,5:0,5,5
attr DB_Service_Schedule webCmd cmd_1:cmd_2:cmd_3
attr DB_Service_Schedule webCmdLabel monatlich :wöchentlich :wöchentlich Löschen :
</syntaxhighlight>

==Wetter-/Leistungs-Prognose==
Bei der Leistungsprognose gibt es nun eine gravierende Veränderung. Die bisherige Leistungsprognose durch eine eigene Berechnung, die auf diversen Konfigurationsparametern basiert hat wurde vollständig durch eine KI_Prognose abgelöst. Die bisherige Implementierung wird nicht mehr weiter entwickelt und ist hier nur noch zu Dokumentationszwecke aufgeführt.

==Wetter-/Leistungs-Prognose KI_Prognose==
Erstmalig wurde die [https://forum.fhem.de/index.php?msg=1268412 KI_Prognose hier im Forumsthread in vier Teil Posts] beschrieben. Im weiteren Thread sind auch noch Informationen dazu zu finden.

===KI Prognose - Grundgedanke===
Nun ist der Ansatz der KI eingezogen und meine Ergebnisse, von bisherigen Tests, sehen schon ziemlich gut aus.

Der Grundgedanke ist, dass die Prognose keinerlei technischen Informationen über den Aufbau der PV-Anlage benötigt. Einzig allen der Ertrag der Anlage wird dabei in Bezug zu den Wetterdaten des jeweiligen Standortes gesetz, wobei die KI daraus Rückschlüsse zieht, wie bei ähnlichen Bedingungen der ertrag werden könnte. Je mehr vergleichbare Daten dazu zur Verfügung stehen, umso besser wird die Prognose.

In der momentan implementierten Prognose besteht darüber hinaus ein Problem, das man die momentan erzeugte Leistung eigentlich mit der zu erwartenden Energieprognose vergleicht.
Beim neuen Ansatz wird nun versucht das mit zu korrigieren, was auch im Diagramm durch die Stufen Darstellung verdeutlicht wird.

Die KI Prognose arbeitet nun über den Yield, den der Plenticore jede Stunde aktualisiert. Bei diesem Yield ist nun jedoch ein weiteres Problem, da der hybrid Wechselrichter natürlich auf der AC Seite den Yield angibt und somit das Laden des Speichers nicht aktuell mit zählt. Die Speicher Entladung wird später dann wiederum mit gerechnet, was die AC Yield Kurve dann sehr merkwürdig aussehen lässt. An dieser Problematik wurde auch bereits gearbeitet und das wird dann später nochmal erwähnt.

Im Diagramm sieht man nun in blau den korrigierten Yield unter Berücksichtigung des Speichers und in diesem Beispiel Fall für eien gesamten Schwarm (ich habe zwei WR). Jede Stufe im Diagramm ist dann nun der Ertrag (Yield) der entsprechenden Stunde in kWh.
Zur Orientierung sieht man in gelb die AC Leistung in kW, gezeichnet aus den minütlichen Messwerten.
Die rosa Stufen sind dann nun endlich die Ertrags Prognose Werte aus der KI in kWh.

===KI Prognose Teil 1 - DWD und Astro Daten sammeln===
Solltet Ihr später mit in diese Richtung gehen wollen, so macht es Sinn [b]schon jetzt die Wetterdaten für Euren Standort zu sammeln[/b], da diese die Grundlage bilden und im Anschluss mit dem korrigierten Ertrag in Verbindung gebracht werden. Alle im comment angegebenen DWD Werte werden später von der KI ausgewertet und müssen somit in der DbLog vorliegen. Je mehr DWD Daten von den letzten Jahren vorliegen, umso besser kann die KI Rückschlüsse ziehen. Sollten diese nicht da sein, so lernt das ganze langsam dazu.

====RAW Definition DWD_Forecast====
Erfordert ggf.
<syntaxhighlight lang="Perl">
sudo apt-get install libxml-libxml-perl
</syntaxhighlight>

===RAW Definition DWD_Forecast===
*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_DWD_Forecast.txt Beispiel DWD_Forecast]

===Astro Device===
Da die KI Prognose ja auch die Astro Daten für den Sonnenstand benötigt und dieser im Astro Device nicht als fc[0|1] vorliegt habe ich das Astro Device etwas modifiziert. In den userreadings werden dort die fc[0|1] Sonnenstände jetzt abgefragt und als readings eingetragen. Dies geschieht sobald es einen Event von ObsDate gibt, der einmal täglich kommen sollte. Somit beachtet auch die Änderung bei event-on-update-reading und beim DbLogInclude.
====RAW Definition Astro====
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_Astro.txt Beispiel Astro]

====fhem.cfg Einträge für das Astro Device====
Hier müsst Ihr Eure Position und Höhe eintragen.
<syntaxhighlight lang="Perl">
attr global altitude 110
attr global latitude 47.xxxxx
attr global longitude 9.yyyyy
</syntaxhighlight>

===KI Prognose Teil 2 - Vorbereitung der Daten===
In diesem Teil geht es darum die Daten aus der FHEM History so aufzubereiten, dass sie für die KI Prognose verwendbar wird. Das Daten Model der FHEM History ist in der Form nicht für diese Verarbeitung brauchbar und wird deshalb in eine neu Tabelle überführt. Bei der Gelegenheit wird einiges noch aufbereitet und insbesondere der yield des Plenticore mit Speicher korrigiert.

====RAW Definition dwd_load() MySQL Procedure====
Hier kommt nun die MySQL Procedure, die in der Datanbank hinterlegt wird. Dazu verwende ich z.B. die MySQL Workbench, wo dann die Procedure unter "Stored Precedures" auftaucht. Dies ermöglicht, dass man im FHEM DbRep Device nur diese eine Procedure aufrufen kann und nicht jedes einzelne SELECT zur Datenbank in einer separaten Session übermittelt werden muss.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/MySQL_dwd_load_Procedure.txt Beispiel dwd_load MySQL Procedure]

====dwd_load() in einzelnen Schritten====
<pre>
1. Löschen der bisherigen dwdfull Tabelle
2. Anlegen einer neuen dwnfull Tabelle
3. Füllen der Tabelle mit den älteren rad1h Werten
4. Ergänzen der rad1h Werte für den nächsten Tag

5. Nun erfolgen alle weiteren DWD Daten in weiteren Spalten der dwdfull Tabelle
1. TTT : Temperature 2m above surface [°C]
2. FF : Windspeed
3. Neff : Effective cloud cover [%]
4. R101 : Probability of precipitation > 0.1 mm during the last hour [%]
5. R600 : Probability of precipitation > 0.0mm during the last 6 hours [%]
6. RRs1c : Snow-Rain-Equivalent during the last 3 hours [kg/m2]
7. Rad1h : Global Irradiance [kJ/m2]
kJ/m² Umrechnung *0,277778 in kWh/m²
8. ww : Significant Weather
9. wwM : Probability for fog within the last hour [%]

6. Zum Schluss wird noch der yield der kompletten PV-Anlage ergänzt
1. Begonnen wird mit dem AC yield, der stundenweise aus dem Zähler "SW_Yield_Daily" berechnet wird
dieser ist jedoch wegen des DC seitigen Speichers nicht korrekt, da in einem Graphen die PV-Leistung
erst nach dem entladen zugerechnet wird
2. Nun wird der DC yield des Speichers berücksichtigt, was über diese Werte geschieht
1. Battery_Total_DC_ChargeEnergy_DCsideToBattery
2. Battery_Total_DC_DischargeEnergy_DCsideFromBattery
3. Die Ermittlung einer stunden basierten Tabelle ist etwas komplexer und bedarf diverser SELECT mit JOIN (Im MySQL gibt es kein full JOIN)

7. Der letzte Schritt ist dann die Möglichkeit einer Rückmeldung aus der MySQL Procedure ins FHEM
8. Über den Parameter show/none wird der Prozedure die Art der Rückmeldung mitgeteilt
1. none wäre der Default und gibt als Ergebnis das aktuelle Datum der Datenbank zurück
2. show würde den Inhalt der dwnfull Tabelle an FHEM zurück liefern, was jedoch einige hundert Zeilen sein werden

9. Die Procedure selectiert nur die entscheidenden Daten für die jeweilige KI Prognose, um das Datenvolumen gering zu halten,
denn es macht ja keinen Sinn, die Winter mit den Sommer Daten zu vergleichen

10. Hierbei werden deshalb folgende Zeiträume jeweils selectiert
1. Die letzten 30 Tage ab dem aktuellen Datum
2. Vom letzten Jahr 30 Tage vor dem Datum
3. Vom letzten Jahr 30 Tage nach dem Datum
4. Vom vorletzten Jahr 30 Tage vor dem Datum
5. Vom vorletzten Jahr 30 Tage nach dem Datum
6. Die Forecast Daten für den nächsten Tag,
an dieser Stelle wäre es natürlich auch denkbar noch weiter in die Zukunft zu gehen,
was mir jedoch zu spekulativ ist und nach meiner Meinung bisher für keine Entscheidung von Wichtigkeit wäre.

11. Die Laufzeit dieser Procedure beträgt auf meinem RPI4 in einem Oracle MySQL Docker Container ca. 50-70 Sekunden,
deshalb musste ich bei mir den Timeout der MySQL Workbench für eine Session von 60 Sekunden auf z.B 90 Sekunden erhöhen

12. In einem Interface Eurer Wahl zur Datenbank könnt Ihr die Procedure zum Testen dann aufrufen und das Ergebnis testen.
</pre>

====dwd_load() Test in MySQL aufrufen====
<syntaxhighlight lang="SQL">
call dwd_load(curdate(),'none');

select * from dwdfull
-- WHERE TIMESTAMP > curdate()
order by TIMESTAMP desc
LIMIT 1000;
</syntaxhighlight>

Sollte nun der Test der Procedure eine gefüllte Tabelle anzeigen, so kann die Integration ins FHEM erfolgen. Hierzu wird dann ein DbRep Device angelegt, dass später zyklisch jede Stunde ausgeführt wird.

====RAW Definition LogDBRep_PV_KI_Prognose (Teil 1)====
Achtung, bei diesem Device kommt im weiteren Fortschritt noch ein weiteres Attribut zum Aufruf des Python KI Prognose Skriptes hinzu. Im Kommentar wird dies bereits im Syntax erwähnt.
<syntaxhighlight lang="Perl">
defmod LogDBRep_PV_KI_Prognose DbRep LogDB
attr LogDBRep_PV_KI_Prognose DbLogExclude .*
attr LogDBRep_PV_KI_Prognose allowDeletion 0
attr LogDBRep_PV_KI_Prognose comment Version 2023.02.23 12:00\
\
Hier wird die Vorbereitung für die KI PV-Leistungsprognose durchgeführt\
\
sqlCmd call dwd_load(curdate(),'none');;\
[none|show] zum Anzeigen des Ergebnisses\
\
executeAfterProc:\
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
attr LogDBRep_PV_KI_Prognose executeAfterProc "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc"
attr LogDBRep_PV_KI_Prognose room System
attr LogDBRep_PV_KI_Prognose verbose 3
</syntaxhighlight>
Auch hier sollte nun getestet werden, indem man beim set das sqlCmd ausführt. Der MySQL Procedur Aufruf ist ebenfalls im Kommentar zu finden.

Als Ergebnis sollte soetwas zurück kommen. Nachdem das erschienen ist kann man den obigen Test mit dem SELECT der dwdfull Tabelle nochmals wiederholen.
<syntaxhighlight lang="Perl">
SqlResultRow_1 NOW()
SqlResultRow_2 2023-03-17 11:01:03
sqlCmd call dwd_load(curdate(),'none');
sqlResultNumRows 1
</syntaxhighlight>

===DbLog/DbRep Device===
====RAW Definition LogDB====
Achtung, bitte hier beachten, ob bereits eine andere DbLog verwendet wird.
<syntaxhighlight lang="Perl">
defmod LogDB DbLog ./db.conf .*:.*
attr LogDB DbLogExclude .*
attr LogDB DbLogSelectionMode Exclude/Include
attr LogDB DbLogType History
attr LogDB asyncMode 1
attr LogDB bulkInsert 1
attr LogDB disable 0
attr LogDB room System
attr LogDB showproctime 1
attr LogDB verbose 0
</syntaxhighlight>

====RAW Definition LogDBRep_PV_KI_Prognose====
Bitte beachtet, dass die Namen auch in anderen Devices eingetragen sind, wenn Ihr diese verändern wollt.

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/RAW_LogDBRep_PV_KI_Prognose.txt Beispiel LogDBRep_PV_KI_Prognose]

====KI Prognose Teil 3 - Python KI Prognose Skript====
Für die Verwendung der KI Prognose werden die folgenden Python Packages noch benötigt. Die Basis wäre hierbei der FHEM Docker Container.
<pre>
Momentan habe ich das erstmal manuell im Container gemacht:

sudo apt-get install python3-pandas
sudo apt-get install python3-pymysql
sudo apt-get install python3-sqlalchemy
sudo apt-get install python3-sklearn python3-sklearn-lib
pip3 install fhem

Für Docker sollte das im .yml File dann so aussehen:

-e PIP_PKGS="pandas pymysql sqlalchemy sklearn sklearn-lib"
ob das mit dem "pip3 install fhem" so geht habe ich nicht getestet

Die Python Skripte liegen bei mir im Ordner

./python/bin
[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/KI_Prognose/PV_KI_Prognose.py ./python/bin/PV_KI_Prognose.py]
</pre>

Das PV_KI_Prognose.py wir mit folgenden Paramerter aufgerufen:
<syntaxhighlight lang="Perl">
<absoluter Skript Name> <DbLog IP-Adresse> <FHEM IP-Adresse> <DbRep Name> <Wechselricher Name> <Prefix Reading Name>
z.B. /opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.XXX 192.168.178.YYY LogDBRep_PV_KI_Prognose WR_1 Solar_yield_fc
<syntaxhighlight>
<pre>
1. Zum Test kann dies auch in "" in der FHEM Kommandozeile eingegeben werden, zuvor muss jedoch die MySQL Prozedur aufgerufen worden sein, damit die benötigte Tabelle mit den Daten erstellt worden ist.
2. Nach dem Testen kommt dieser Aufruf dann in das LogDBRep_PV_KI_Prognose Device und wird somit mit dem MySQL Prozeduraufruf synchronisiert.
Bitte das LogDBRep_PV_KI_Prognose Device (Teil 1) aus dem vorherigen Absatz verwenden.
Damit dann alles automatisch gestartet wird muss nun noch im WR_ctl Device ein Eintrag eingefügt werden.
3. Achtung, das WR_ctl Device beinhaltet jetzt die Forecast Daten und nicht wie früher das WR_1 Device.
<pre>
<syntaxhighlight lang="Perl">
< snip >
################################################################################################################
## 2 Start der KI Prognose
## Der Reading Name und das Device werden in LogDBRep_PV_KI_Prognose im executeAfterProc eingestellt
## "/opt/fhem/python/bin/PV_KI_Prognose.py 192.168.178.40 192.168.178.40 LogDBRep_PV_KI_Prognose WR_1_ctl Yield_fc"
##
2_KI_Prognose
{if( !([$SELF:state] eq "off") ## DOIF enabled
and
ReadingsVal("LogDBRep_PV_KI_Prognose","PV_KI_Prognose","null") eq "done" ## Die Prognose darf nicht gerade laufen !!!
and
(
([05:00-22:00] and [:03] ## In der PV-Zeit jede Stunde aktualisieren
)
or [$SELF:ui_command_1] eq "2_KI_Prognose" ## Hier wird das uiTable select ausgewertet
)
) {

::CommandSet(undef, "LogDBRep_PV_KI_Prognose sqlCmd call dwd_load(curdate(),'none')");

if (AttrVal("$SELF","verbose",0) >=3) {
Log 3, "$SELF 2_KI_Prognose : Start KI Prognose";
}

set_Reading("ui_command_1","---"); ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten
## kann das Kommando nicht sofort wiederholt werden
}
}
< snip >
<syntaxhighlight>

Für die Netzwerkverbindung aus dem KI Python Skript werden die Zugansdaten im Filesystem abgelegt, damit sie nicht mit dem Skript ausversehen weiter gegeben werden.
<pre>
./python/pwd_fhem.json
./python/pwd_sql.json
</pre>
Die Verbindungsdaten werden in den Dateien wie folgt abgelegt:
<syntaxhighlight lang="Perl">
fhem@raspberrypi:~/python$ cat pwd_[fhem|sql].json
{"username": "<Euer Username>",
"password": "<Euer Passwort>"}
<syntaxhighlight>
<pre>
FHEM und die Datenbank müssen nicht auf dem selben Rechner installiert werden. Die IP-Adressen werden dem Skript beim Aufruf mitgegeben.

Es ist nicht erforderlich die neuen readings mit DbLogInclude aus dem WR_1 Device in die Datenbank zu loggen, da dies bereits durch das PV_KI_Prognose Skript direkt geschieht, um einen passenden TIMESTAMP pro Stunde zu bekommen.
</pre>
Wenn im LogDBRep_PV_KI_Prognose der verbose Level auf >= 3 steht kommen diverse Meldungen im Log:
<syntaxhighlight lang="Perl">
/usr/lib/python3/dist-packages/sklearn/externals/joblib.py:1: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
PV_KI_Prognose running - start
PV_KI_Prognose running - connected to 192.168.178.40
PV_KI_Prognose running - dwdfull read from DbLog 192.168.178.40
PV_KI_Prognose running - RandomForestRegressor loading
PV_KI_Prognose running - RandomForestRegressor loaded
PV_KI_Prognose running - RandomForestRegressor trained
PV_KI_Prognose running - RandomForestRegressor fitted with yield
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc0_06 06 71
Yield_fc0_07 07 406
Yield_fc0_08 08 1629
Yield_fc0_09 09 3248
Yield_fc0_10 10 4664
Yield_fc0_11 11 6210
Yield_fc0_12 12 7078
Yield_fc0_13 13 5455
Yield_fc0_14 14 4034
Yield_fc0_15 15 1189
Yield_fc0_16 16 275
Yield_fc0_17 17 170
Yield_fc0_18 18 56
Yield_fc0_19 19 43
Yield_fc0_20 20 0
--------------------------------------------
max off/at 7078 12:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 99
rest 99
morning 16228
afternoon 18300
day 34528
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose running - old forecast deleted
PV_KI_Prognose running - start forecast
Yield_fc1_06 06 64
Yield_fc1_07 07 406
Yield_fc1_08 08 2103
Yield_fc1_09 09 4785
Yield_fc1_10 10 6902
Yield_fc1_11 11 7911
Yield_fc1_12 12 7078
Yield_fc1_13 13 5455
Yield_fc1_14 14 4034
Yield_fc1_15 15 1189
Yield_fc1_16 16 275
Yield_fc1_17 17 170
Yield_fc1_18 18 55
Yield_fc1_19 19 46
Yield_fc1_20 20 0
--------------------------------------------
max off/at 7911 11:00
Middayhigh_start 00:00
Middayhigh_stop 00:00
4h 101
rest 101
morning 22171
afternoon 18302
day 40473
--------------------------------------------
PV_KI_Prognose running - forecast written to FHEM
PV_KI_Prognose done
<syntaxhighlight>

==Diagramme mit Grafana==
Grafana kann z.B. mit docker auf dem selben oder auch einem anderen System installiert werden. Es ermöglicht die Darstellung von Diagrammen und Dashboards durch die direkte Abfrage aus einer Datenbank.
===Beispiel Diagramme===
[[Datei:Leistung und Hauptverbraucher.png|mini|600px|rechts|]]
[[Datei:Forecast.png|mini|600px|rechts|]]
<pre>
Die verwendete Datenbank ist im Grafana als "FHEM MySQL" am besten vorher zu konfigurieren.
Achtung, dieses Dashboard verwendet die Schwarm readings bei den MySQL SELECT!
Eine Anpassung wäre denkbar, wenn man im JSON File "SW_" global entfernt.
Auch die Hauptverbraucher sind im Diagramm anzupassen, da sie bei mir durch eigene Zähler erfasst werden. Sollten bei Euch keine Zähler vorhanden sein, so müsstet Ihr den jeweiligen Verbraucher im Diagramm löschen.
</pre>
'''Im JSON File sind noch weitere Kommentare enthalten, die bitte auch gelesen werden sollten.'''

*[https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Dashboard/Kostal-Flow_V2_JSON.txt Beispiel Grafana Dashboard]

==Diagramme mit Grafana==
Grafana ermöglicht das direkte Auslesen der SQL Datenbank und kann auch auf einer anderen Plattform betrieben werden. Bei mir befindet es sich in Docker Containern auf dem selben RPI4.
=== RAW Definition Hauptverbraucher ===
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/ Beispiele]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Hauptverbraucher_JSON.txt Beispiel Hauptverbraucher]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_KI_Prognose_JSON.txt Beispiel KI_Prognose]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Grafana/Diagramme/Diagramm_Leistungsbezug_JSON.txt Beispiel Leistungsbezug]

== PV Eigenverbrauch-Steuerung ==
'''Hier werde ich auch mal aktualisieren, bei bedarf einfach im Forum fragen.'''
=== Beispiel Luft Wärme Pumpe Novelan LAD ===
Hier mal ein paar Bilder für die Dokumentation der PV-Modus Anschaltung mit einem Shell 1 und das Heizelement, dass man über Lastrelais in drei Stufen Regeln könnte. Die Aktivierung der Zusatzheizung ist über das Luxtronik2 Modul möglich.
<gallery>
LAD_Zusatzheizung_2_4_6_kW.jpg|Zusatzheizung 2/4/6 kW
LAD_Shelly_Einbauposition.jpg|LAD Shelly Einbauposition
LAD_Shelly_Phase_und_Null.jpg|LAD Shelly Phase und Null
LAD_Shelly_SWT-Signal.jpg|LAD Shelly SWT-Signal
</gallery>
==== RAW Definition LWP_PV (DOIF im Perl Modus) ====
Hierbei wird das PV-Modus Signal über ein Shelly 1 zur LAD Wärmepumpe übermittelt, was natürlich auch durch ein beliebiges anderes Relais erfolgen kann.
Die setstate Attribute am Ende der RAW Definition sind ebenfalls wichtig, da dort die Default reading Werte für das DOIF gesetzt werden. Diese können dann über die uiTable Definitionen mit Pull Down Menüs geändert werden.

* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/ Beispiel Wärmepumpe Novelan LAD9 mit vorgeschaltetem Stromzähler]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_PV_Perl.txt Beispiel LWP_PV_Perl PV Eigenverbrauch Steuerung]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_LWP_Counter.txt Beispiel LWP_Counter]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/Photovoltaik/W%c3%a4rmepumpe_Novelan_LAD9/RAW_shelly01.txt Beispiel Shelly PV Modus Umschaltung]

=== Beispiel Pool Softube ===
==== RAW Definition Pool_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Pool_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Pool_Status] eq "Aus" ## Der Pool ist aus\
and [Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit des Pools ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_1 : Pool on waiting"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Pool_Status","An");;PV_Modus_Ein_Pool()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Pool_Status","Wartend");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_2 : Pool on for manuel usage"};;\
\
set_Reading("Pool_Status","manuell");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell den Pool abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 01_3 : Pool off after manuel usage"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Pool_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and ( [$SELF:Pool_Status] eq "An" ## Der Pool läuft\
or [$SELF:Pool_Status] eq "pflege")\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_1 : Pool off Laufzeit"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und die PV Produktion unter dem Mindestbedarf ist\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [WR_1:Home_own_consumption_from_grid] ## Nicht zuviel Bezug aus dem Netz\
+ [WR_1:Home_own_consumption_from_Battery]) > 100 ## oder dem Speicher\
and [Pool_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Pool_Status] eq "An" ## Der Pool läuft (nicht bei manuell)\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 02_2 : Pool off PV-Min"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < 5 ## läuft die Wartezeit bald ab\
and [$SELF:Pool_Status] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 03__ : Stop wait timer Pool"};;\
del_Exec("PV_Modus_Ein_timer");; ## Der Pool wird nicht mehr eingeschaltet\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Ende\
##\
05___Pool_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly02:power_0] < 10 ## Die Poolpumpe ist bereits\
and [Pool_Counter:pauseTimeIncrement] > 900 ## seit 5 Minuten aus\
and [$SELF:Pool_Status] ne "Aus" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Pool_Status] ne "Wartend" ## und es wird nicht wegen eines Peaks gewartet\
)\
or [$SELF:ui_command_1] eq "05___Pool_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 05__ : Pool run finished ".[shelly02:power_0]." ".[Pool_Counter:pauseTimeIncrement]};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] or\
[Heizung:averageAmbientTemperature] <= 10 ) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 08__ : Pool switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pool durch kürzere Laufzeit abkühlen lassen\
##\
09___Laufzeit_im_Sommer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
[06:15] and [Heizung:averageAmbientTemperature] ## Pool durch kürzere Laufzeit abkühlen lassen\
or [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "09___Laufzeit_im_Sommer" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [Heizung:averageAmbientTemperature] >= 18 ) {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDaySummer]);;\
} else {\
set_Reading("RunTimePerDay",[$SELF:RunTimePerDayWinter]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 09__ : Pool switched to RunTimePerDay ".ReadingsVal("$SELF","RunTimePerDay",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Pflege Zwangseinschaltung: Es muss mindestens einmal pro Tag eingeschaltet werden, auch wenn kein PV Strom vorhanden war.\
##\
10___Pool_Pflege\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]] ## Hier sollte der Pool bereits gelaufen sein\
and\
([Pool_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] or ## Ist er zuwenig gelaufen\
[Pool_Counter:countsPerDay] eq 0) ## oder eventuell garnicht\
)\
or [$SELF:ui_command_1] eq "10___Pool_Pflege" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "10___Pool_Pflege" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on for maintanance"};;\
\
set_Reading("Pool_Status","pflege");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Im Herbst Winter den Pool bei günstigem Strom in der Nacht zusätzlich einschalten\
##\
11___Nachtstrom_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "onx" ## Gibt es günstigen Strom an der Börse\
and [22:00-05:00] ## nur in dieser Zeit verwenden\
)\
or [$SELF:ui_command_1] eq "11___Nachtstrom_An" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "11___Nachtstrom_An" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool on Nachtstrom by aWATTar"};;\
\
set_Reading("Pool_Status","Nachtstrom");;\
PV_Modus_Ein_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Sobald der Strompreis wieder teurer wird den Pool abschalten\
##\
12___Nachtstrom_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit] ## Im Herbst/Winter ist wenig zu erwarten\
and [EVU_Kosten:aWATTar_Trigger] eq "off" ## Gibt es günstigen Strom an der Börse\
and [$SELF:Pool_Status] eq "Nachtstrom" ## und gibt es keine manuelle Einschaltung\
)\
or [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ## Hier wird das uiTable select ausgewertet\
) { \
if( [$SELF:ui_command_1] eq "12___Nachtstrom_Aus" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV 10__ : Pool off after Nachtstrom by aWATTar"};;\
\
PV_Modus_Aus_Pool();;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Pool() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool on"};;\
## {fhem("set Pool_Counter pulseTimeIncrement 0")} ## das sollte eigentlich raus\
fhem("set Pool_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Pool() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "Pool_PV sub : Pool off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Pool_Status","Aus");;\
}\
}
attr Pool_PV_Perl DbLogExclude .*
attr Pool_PV_Perl alias Pool_PV_Perl
attr Pool_PV_Perl comment Version 2021.11.01 09:00
attr Pool_PV_Perl disable 0
attr Pool_PV_Perl event-on-change-reading .*
attr Pool_PV_Perl group PV Eigenverbrauch-Steuerung
attr Pool_PV_Perl icon scene_swimming
attr Pool_PV_Perl room Strom->Photovoltaik
attr Pool_PV_Perl sortby 421
attr Pool_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Pumpe Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_abschalten_Laufzeit,02_2_Eigenverbrauch_abschalten_PV_Min,03___Stop_Wait_Timer,05___Pool_Ende,08___Startzeit_nach_forecast,09___Laufzeit_im_Sommer,10___Pool_Pflege,11___Nachtstrom_An,12___Nachtstrom_Aus") |[$SELF:Pool_Status]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly02:power_0] > 10)?'Pool_Pumpe_laeuft' : 'Pool_Pumpe_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,100,50,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,50,50,2000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter / RunTimePerDay / Start / Ende</dd>"| ""|widget([$SELF:RunTimePerDaySummer],"selectnumbers,900,300,28800,0,lin")." ".widget([$SELF:RunTimePerDayWinter],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Pool_PV_Perl verbose 3

setstate Pool_PV_Perl 2022-10-23 16:44:33 Pool_Status Aus
setstate Pool_PV_Perl 2022-06-30 12:48:47 PowerLevelMinTime 300
setstate Pool_PV_Perl 2022-05-10 15:51:44 PowerLimitOff 100
setstate Pool_PV_Perl 2022-05-10 15:50:44 PowerLimitOn 1000
setstate Pool_PV_Perl 2022-05-10 15:55:23 RunTimeMin 7200
setstate Pool_PV_Perl 2022-10-23 06:15:00 RunTimePerDay 28800
setstate Pool_PV_Perl 2021-06-23 14:55:42 RunTimePerDaySummer 7200
setstate Pool_PV_Perl 2020-10-06 14:14:13 RunTimePerDayWinter 28800
setstate Pool_PV_Perl 2022-05-10 16:23:06 SetCmdOff set shelly02 off 0
setstate Pool_PV_Perl 2022-05-10 16:23:24 SetCmdOn set shelly02 on 0
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeEnd 16:00
setstate Pool_PV_Perl 2021-12-01 17:39:32 TimeEndSummer 16:00
setstate Pool_PV_Perl 2021-12-05 14:20:48 TimeEndWinter 16:00
setstate Pool_PV_Perl 2022-10-23 07:17:00 TimeStart 12:35
setstate Pool_PV_Perl 2022-06-30 12:48:23 TimeStartSummer 12:35
setstate Pool_PV_Perl 2020-09-03 13:10:56 TimeStartWinter 09:10

setstate Pool_PV_Perl 2022-10-30 11:25:40 ui_command_1 ---
setstate Pool_PV_Perl 2022-10-16 19:59:44 ui_command_1_before ---
</syntaxhighlight>
==== RAW Definition Pool_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly02 Shelly 192.168.178.52
attr shelly02 DbLogExclude .*
attr shelly02 DbLogInclude relay.*,power.*,energy.*
attr shelly02 alias Pool
attr shelly02 comment Version 2020.10.19 18:28\
relais_0 => Pool limit 1000 W\
relail_1 => Terrasse Lichterkette limit 100 W
attr shelly02 event-on-change-reading relay.*,energy.*,state,network
attr shelly02 event-on-update-reading power.*
attr shelly02 group PV Eigenverbrauch-Steuerung
attr shelly02 icon taster_ch_1
attr shelly02 mode relay
attr shelly02 model shelly2.5
attr shelly02 room Shelly,Strom->Photovoltaik
attr shelly02 sortby 422
attr shelly02 stateFormat {\
my $status = (ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error";;\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_0_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay_0","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power_0",0));;\
\
my $e1 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_1_Total",0)/1000);;\
my $r1 = (ReadingsVal($name,"relay_1","") eq "off") ? "off":"on";;\
my $p1 = sprintf("%06.1f Watt",ReadingsVal($name,"power_1",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
Status: $status\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Pool Gesamt 0: $e0 \
JEL Gesamt 1: $e1</td>\
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
Relais 1: $r1 $p1\
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly02 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_0_Total:energy_0.* monotonic { ReadingsVal($name,"energy_0",0) },\
energy_1_Total:energy_1.* monotonic { ReadingsVal($name,"energy_1",0) }\

attr shelly02 verbose 0
attr shelly02 webCmd |
</syntaxhighlight>

=== Beispiel Waschmaschine (mit Walzenschalter ;-) ) ===
==== RAW Definition Waschmaschine_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_PV_Perl DOIF ################################################################################################################\
## Eigenverbrauch einschalten: wenn PV Produktion über dem Mindestbedarf ist und die Laufzeit pro Tag noch nicht erreicht ist\
##\
01_1_Eigenverbrauch_automatisch_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] >= [$SELF:PowerLimitOn] ## Es besteht PV-Überschuss\
and [[$SELF:TimeStart]-[$SELF:TimeEnd]] ## Das Zeitfenster ist erreicht\
and get_Exec("PV_Modus_Ein_timer") < 1 ## Der Wait Timer ist noch nicht gestartet\
and [$SELF:Status_1] eq "Aus" ## Die Waschmaschine ist aus\
and [Waschmaschine_Counter:pulseTimePerDay] < [$SELF:RunTimePerDay] ## Die maximale Laufzeit der Waschmaschine ist noch nicht erreicht\
)\
or [$SELF:ui_command_1] eq "01_1_Eigenverbrauch_automatisch_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_1 : Waiting for ".([$SELF:PowerLevelMinTime]/60)." Minutes"};;\
\
set_Exec("PV_Modus_Ein_timer",[$SELF:PowerLevelMinTime],'set_Reading("Status_1","An");;set_Reading("Status_2","PV Überschuss An");;PV_Modus_Ein_Waschmaschine()');; ## Den PV-Modus verzögert einschalten\
set_Reading("Status_1","Wartend");;\
set_Reading("Status_2","für ".([$SELF:PowerLevelMinTime]/60)." Minuten");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuell das Gerät einschalten.\
##\
01_2_Eigenverbrauch_manuell_An\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [$SELF:Status_1] eq "Aus"\
and [shelly03:relay] eq "on" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_2_Eigenverbrauch_manuell_An" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_2 : On for manuel usage"};;\
\
del_Exec("PV_Modus_Ein_timer");;\
set_Reading("Status_1","manuell");;\
PV_Modus_Ein_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell An");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Manuelle Verwendung abschalten.\
##\
01_3_Eigenverbrauch_manuell_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( ( [$SELF:Status_1] eq "An"\
or [$SELF:Status_1] eq "manuell")\
and [shelly03:relay] eq "off" ## Der Taster wurde gedrückt\
)\
or [$SELF:ui_command_1] eq "01_3_Eigenverbrauch_manuell_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 01_3 : Off after manuel usage"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Steckdose manuell Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
################################################################################################################\
## Eigenverbrauch abschalten: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
##\
02_1_Eigenverbrauch_Laufzeit_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [Waschmaschine_Counter:pulseTimePerDay] >= [$SELF:RunTimePerDay] ## Die Tages Laufzeit ist überschritten\
and [Waschmaschine_Counter:pulseTimeIncrement] >= [$SELF:RunTimeMin] ## Die Mindestlaufzeit ist überschritten\
and [$SELF:Status_1] eq "An" ## Das Gerät läuft\
)\
\
or [$SELF:ui_command_1] eq "02_1_Eigenverbrauch_Laufzeit_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_1 : Off by runtime"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","Laufzeit Max Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Eigenverbrauch abschalten: falls die Waschmaschine doch nicht benötigt wurde\
##\
02_2_Eigenverbrauch_PV_Min_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Der Überschuss ist zu wenig\
and [$SELF:Status_1] eq "An" ## und die Waschmaschine wartet\
and [$SELF:Status_2] eq "PV Überschuss wartend" ## auf den start\
)\
or [$SELF:ui_command_1] eq "02_2_Eigenverbrauch_PV_Min_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 02_2 : PV-Minimum unterschritten"};;\
\
PV_Modus_Aus_Waschmaschine();;\
set_Reading("Status_2","PV Min Aus");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Stop, wenn es nur ein kurzer peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4 wieder außer kraft,\
## wenn während der Wartezeit die PV Anlage zuwenig liefert.\
##\
03___Stop_Wait_Timer\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
( [WR_1:SW_Total_PV_P_reserve] < [$SELF:PowerLimitOn] ## Ist die PV-Leistung zu niedrig?\
and get_Exec("PV_Modus_Ein_timer") > 0 ## läuft eine Wartezeit\
and get_Exec("PV_Modus_Ein_timer") < [$SELF:PowerLevelMinTime] ## läuft die Wartezeit bald ab\
and [$SELF:Status_1] eq "Wartend" ## und gibt es keine manuelle Einschaltung\
)\
)\
or [$SELF:ui_command_1] eq "03___Stop_Wait_Timer" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 03__ : Stop wait timer"};;\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","warten gestoppt");;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_1_Waschprogramm_wartend\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] < 1 ## Das Gerät ist bereits\
and [Waschmaschine_Counter:pauseTimeIncrement] > 120 ## seit 2 Minuten aus\
and [$SELF:Status_1] eq "An" ## und gibt es keine manuelle Einschaltung\
and\
( [$SELF:Status_2] eq "PV Überschuss An" ## falls die Waschmaschine nicht gebraucht\
or [$SELF:Status_2] eq "PV Überschuss wartend") ## wird einfach weiter warten\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "04_1_Waschprogramm_wartend" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_1 : Waschmaschine ist nicht gestartet"};;\
\
set_Reading("Status_2","PV Überschuss wartend");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Statuswechsel wenn das Waschprogramm gestartet ist\
##\
04_2_Waschprogramm_gestartet\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] > 0 ## Das Gerät ist bereits gestartet\
## and [shelly03:power_Waschmaschine_avg] < 70 ## und verbraucht mehr Leistung als im Standby\
and [$SELF:Status_2] ne "Waschprogramm gestartet" ## \
)\
or [$SELF:ui_command_1] eq "04_2_Waschprogramm_gestartet" ## Hier wird das uiTable select ausgewertet\
) {\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 04_2 : Waschprogramm gestartet"};;\
\
set_Reading("Status_2","Waschprogramm gestartet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist gestartet");;\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Gerät Ende\
##\
05_1_Waschprogramm_Ende\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [shelly03:power] == 0 ## Die Waschmaschine hat abgeschaltet\
and [$SELF:Status_2] eq "Waschprogramm gestartet" ## und vorher lief das Waschprogramm\
\
)\
or [$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende" ## Hier wird das uiTable select ausgewertet\
) {\
\
set_Reading("Status_2","Waschprogramm beendet");;\
fhem("set alias=Mobil speak 40 Das Waschprogramm ist fertig");;\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_1 : Waschprogramm beendet"};;\
\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_1_Waschprogramm_Ende") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Gerät Abschalten, wenn es nicht verwendet wurde\
##\
05_2_Waschmaschine_Aus\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
( [[$SELF:TimeEnd]-[$SELF:TimeStart]] ## und auch nicht in der Nachtzeit\
and [$SELF:Status_1] ne "manuell" ## und gibt es keine manuelle Einschaltung\
and [$SELF:Status_2] ne "Waschprogramm gestarted" ## und es läuft kein Waschprogramm\
and [$SELF:ui_command_1] eq "---"\
)\
or [$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus" ## Hier wird das uiTable select ausgewertet\
) {\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 05_2 : Keine PV-Zeit"};;\
\
del_Exec("PV_Modus_Ein_timer");; ## Das Gerät wird nicht mehr eingeschaltet\
PV_Modus_Aus_Waschmaschine();;\
\
if ([$SELF:ui_command_1] eq "05_2_Waschmaschine_Aus") {\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
}\
\
################################################################################################################\
## Geräte Startzeit durch Forecast verschieben. Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
##\
08___Startzeit_nach_forecast\
{if( !([$SELF:state] eq "off") ## DOIF enabled\
and\
(\
[07:17] ## Der Forecast wird um 7:00 im Device PV_Schedule aktualisiert\
or [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ## Hier wird das uiTable select ausgewertet\
)\
) {\
if( [$SELF:ui_command_1] eq "08___Startzeit_nach_forecast" ) { ## Hier wurde manuell eingeschaltet\
set_Reading("ui_command_1_before",[$SELF:ui_command_1]);;\
}\
\
if( [WR_1:Solar_Calculation_fc0_day] < [WR_1_Speicher_1_ExternControl:SpeicherMinSOC_fc1_Limit]) {\
set_Reading("TimeStart",[$SELF:TimeStartWinter]);;\
set_Reading("TimeEnd",[$SELF:TimeEndWinter]);;\
set_Reading("Status_2","Startzeit für Winter");;\
} else {\
set_Reading("TimeStart",[$SELF:TimeStartSummer]);;\
set_Reading("TimeEnd",[$SELF:TimeEndSummer]);;\
set_Reading("Status_2","Startzeit für Sommer");;\
}\
\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF 08__ : Switched to TimeStart ".ReadingsVal("$SELF","TimeStart",0)." TimeEnd ".ReadingsVal("$SELF","TimeEnd",0)};;\
\
set_Reading("ui_command_1","---");; ## Hier wird das uiTable select wieder zurückgesetzt, ansonsten\
## kann das Kommando nicht sofort wiederholt werden\
}\
}\
\
################################################################################################################\
## Definition von Sub Routinen\
subs {\
sub PV_Modus_Ein_Waschmaschine() { ## PV-Modus Einschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : On"};;\
fhem("set Waschmaschine_Counter pauseTimeIncrement 0");;\
fhem("".ReadingsVal("$SELF","SetCmdOn",0));;\
}\
\
sub PV_Modus_Aus_Waschmaschine() { ## PV-Modus Ausschalten\
if (AttrVal("$SELF","verbose",0) >=3)\
{Log 3, "$SELF sub : Off"};;\
fhem("".ReadingsVal("$SELF","SetCmdOff",0));;\
set_Reading("Status_1","Aus");;\
set_Reading("Status_2","Steckdose ist ausgeschaltet");;\
}\
}
attr Waschmaschine_PV_Perl DbLogExclude .*
attr Waschmaschine_PV_Perl alias Waschmaschine_PV_Perl
attr Waschmaschine_PV_Perl comment Version 2021.11.01 09:00
attr Waschmaschine_PV_Perl disable 0
attr Waschmaschine_PV_Perl event-on-change-reading .*
attr Waschmaschine_PV_Perl event_Readings Status_1:[$SELF:Status_1], Status_2:[$SELF:Status_2]
attr Waschmaschine_PV_Perl group PV Eigenverbrauch-Steuerung
attr Waschmaschine_PV_Perl icon scene_washing_machine
attr Waschmaschine_PV_Perl room Strom->Photovoltaik
attr Waschmaschine_PV_Perl sortby 4311
attr Waschmaschine_PV_Perl uiTable {\
package ui_Table;;\
$TABLE = "style='width:100%;;'";;\
\
$TD{0..9}{0} = "align='center' style='font-size:16px;;border-right-style:solid;;border-color:darkgreen;;border-right-width:2px;;width:26%'";;\
\
$TD{0..9}{1} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:36%;;font-weight:bold;;'";;\
$TD{0..9}{2..4} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:1px;;width:8%;;text-align:center;;'";;\
$TD{0..9}{5} = "style='border-top-style:solid;;border-bottom-style:solid;;border-right-style:solid;;border-color:darkgreen;;border-top-width:2px;;border-bottom-width:2px;;border-right-width:2px;;width:8%;;text-align:center;;'";;\
\
sub FUNC_Status {\
my($value, $min, $colorMin, $statusMin, $colorMiddel, $statusMiddle, $max, $colorMax, $statusMax)=@_;;\
my $ret = ($value < $min)? ''.$statusMin.'' : ($value > $max)? ''.$statusMax.'' : ''.$statusMiddle.'';;\
return $ret;;\
}\
\
}\
\
"$SELF"|"Kommando<dd>Auswahl / Status / / Waschmaschine Status</dd>" |widget([$SELF:ui_command_1],"uzsuDropDown,---,01_1_Eigenverbrauch_automatisch_An,01_2_Eigenverbrauch_manuell_An,01_3_Eigenverbrauch_manuell_Aus,02_1_Eigenverbrauch_Laufzeit_Aus,02_2_Eigenverbrauch_PV_Min_Aus,03___Stop_Wait_Timer,04_1_Waschprogramm_wartend,04_2_Waschprogramm_gestartet,05_1_Waschprogramm_Ende,05_2_Waschmaschine_Aus,08___Startzeit_nach_forecast") |[$SELF:Status_1]." ".[$SELF:Status_2]|::ReadingsTimestamp("$SELF","timer_PV_Modus_Ein_timer","")|(([shelly03:power] > 7)?'Waschmaschine_laeuft' : 'Waschmaschine_aus')\
|"Konfiguration<dd>PowerLevelMinTime, | PowerLimit On/Off | Time Start/End</dd><dd>RunTime Min/PerDay</dd>"|""|widget([$SELF:PowerLevelMinTime],"selectnumbers,60,60,900,0,lin")." ".widget([$SELF:RunTimeMin],"selectnumbers,300,300,7200,0,lin").widget([$SELF:RunTimePerDay],"selectnumbers,900,300,28800,0,lin")|widget([$SELF:PowerLimitOn],"selectnumbers,250,250,2000,0,lin").widget([$SELF:PowerLimitOff],"selectnumbers,0,50,1000,0,lin")|widget([$SELF:TimeStart],"time").widget([$SELF:TimeEnd],"time")\
|"<dd>Sommer, Winter Start / Ende</dd>"| ""|""|widget([$SELF:TimeStartSummer],"time").widget([$SELF:TimeStartWinter],"time").|widget([$SELF:TimeEndSummer],"time").widget([$SELF:TimeEndWinter],"time")
attr Waschmaschine_PV_Perl verbose 3

setstate Waschmaschine_PV_Perl 2022-08-11 09:48:48 PowerLevelMinTime 300
setstate Waschmaschine_PV_Perl 2022-09-26 13:47:21 PowerLimitOff 250
setstate Waschmaschine_PV_Perl 2022-10-06 17:45:40 PowerLimitOn 2000
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:38 RunTimeMin 5400
setstate Waschmaschine_PV_Perl 2022-08-11 09:52:45 RunTimePerDay 19200
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:42 SetCmdOff set shelly03 off 0
setstate Waschmaschine_PV_Perl 2022-08-11 12:27:19 SetCmdOn set shelly03 on 0
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:23 Status_1 -
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 Status_2 -
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeEnd 18:00
setstate Waschmaschine_PV_Perl 2022-10-06 17:32:31 TimeEndSummer 18:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:58 TimeEndWinter 16:00
setstate Waschmaschine_PV_Perl 2022-11-01 07:17:00 TimeStart 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:48:05 TimeStartSummer 08:00
setstate Waschmaschine_PV_Perl 2022-08-11 09:46:54 TimeStartWinter 10:00
setstate Waschmaschine_PV_Perl 2022-11-01 09:21:25 ui_command_1 ---
setstate Waschmaschine_PV_Perl 2022-10-06 19:34:48 ui_command_1_before ---
</syntaxhighlight>

==== RAW Definition Waschmaschine_Signale (Shelly Modul: shelly1pm) ====
<syntaxhighlight lang="Perl">
defmod shelly03 Shelly 192.168.178.55
attr shelly03 DbLogExclude .*
attr shelly03 DbLogInclude relay.*,power.*,energy.*
attr shelly03 alias Waschmaschine
attr shelly03 comment Version 2020.10.19 18:28
attr shelly03 event-on-change-reading relay.*,power.*,energy.*,network
attr shelly03 group PV Eigenverbrauch-Steuerung
attr shelly03 icon taster_ch_1
attr shelly03 interval 60
attr shelly03 mode relay
attr shelly03 model shelly1pm
attr shelly03 room Shelly,Strom->Photovoltaik
attr shelly03 sortby 432
attr shelly03 stateFormat {\
my $link = ReadingsVal($name,"WebLink","none");;\
\
my $e0 = sprintf("%08.2f KWh",ReadingsVal($name,"energy_Total",0)/1000);;\
my $r0 = (ReadingsVal($name,"relay","") eq "off") ? "off":"on";;\
my $p0 = sprintf("%06.1f Watt",ReadingsVal($name,"power",0));;\
\
"<html><table border=2 bordercolor='darkgreen' cellspacing=0 style='width: 100%'>\
<colgroup>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 30%;;'>\
<col span='1' style='width: 20%;;'>\
</colgroup>\
<tr>\
<td style='text-align:left'>\
</td>\
<td style='text-align:left'>\
WebLink: $link\
</td>\
<td style='text-align:right'>\
Waschmaschine Gesamt 0: $e0 \
<td style='text-align:right'>\
Relais 0: $r0 $p0 \
</td>\
</tr>\
</table>\
</html>"\
}
attr shelly03 userReadings WebLink:network.* { my $ip=ReadingsVal($name,"network","na");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<a href='http://".$ip."/'>".$ip."</a>") },\
\
energy_Total:energy.* monotonic { ReadingsVal($name,"energy",0) }
attr shelly03 webCmd |
</syntaxhighlight>
==== RAW Definition Waschmaschine_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Waschmaschine_Counter HourCounter shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,}) shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter DbLogExclude .*
attr Waschmaschine_Counter alias Waschmaschine_Counter
attr Waschmaschine_Counter comment Version 2020.10.19 18:28\
\
Waschmaschine_PV:.*laeuft Waschmaschine_PV:Waschmaschine_Status:.*[beendet|ausgeschaltet]\
\
Version 2022.09.20 16:00\
Bis 3.9 Watt ist das Gerät aus, ab 4 Watt ist es eingeschaltet\
An => shelly03:power:\s([0-9]{2,}\.?[0-9]{0,}|[4-9]{1}\.?[0-9]{0,})\
Aus => shelly03:power:\s([0-3]{1}\.?[0-9]{0,}|[0-3]{1})
attr Waschmaschine_Counter event-on-change-reading .*
attr Waschmaschine_Counter event-on-update-reading power.*
attr Waschmaschine_Counter group PV Eigenverbrauch-Steuerung
attr Waschmaschine_Counter icon time_timer
attr Waschmaschine_Counter interval 5
attr Waschmaschine_Counter room Strom->Photovoltaik
attr Waschmaschine_Counter sortby 433
attr Waschmaschine_Counter verbose 0
</syntaxhighlight>

=== Beispiel Brunnenpumpe (mit extra Taster zum Aktivieren) ===
Das Beispiel für die Brunnenpumpe hat eine Besonderheit. Damit nicht vergessen wird die Brunnenpumpe nach der Benutzung wieder Stromlos zu schalten geschieht dies nach einer eingestellten Zeit, wenn sie nicht verwendet wurde. Also immer schön die Düse geöffnet halten :-) Des weitern kann die Pumpe über einen taster am Shelly2.5 aktiviert werden, was dem Elektriker gesagt werden sollte, damit er die Verdrahtung korrekt macht. Der Shelly2.5 aus diesem Beispiel wird ebenfalls für das nächste Beispiel verwendet, da die Steckdosen nebeneinander sind.
==== RAW Definition Brunnen (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen dummy
attr Brunnen DbLogExclude .*
attr Brunnen DbLogInclude state
attr Brunnen alias Brunnen
attr Brunnen comment Version 2020.10.19 18:28
attr Brunnen group PV Eigenverbrauch
attr Brunnen icon well
attr Brunnen readingList Brunnen_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Brunnen room Strom->Photovoltaik
attr Brunnen setList Brunnen_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Brunnen sortby 13
attr Brunnen stateFormat state
attr Brunnen verbose 0
attr Brunnen webCmd Brunnen_Button

setstate Brunnen off
setstate Brunnen 2020-09-21 16:50:48 Brunnen_Button off
setstate Brunnen 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Brunnen 2019-11-06 10:56:22 PowerLimitOff 600
setstate Brunnen 2020-04-20 13:06:04 PowerLimitOn 900
setstate Brunnen 2019-12-02 15:01:18 RunTimeMin 60
setstate Brunnen 2020-04-02 13:59:34 RunTimePerDay 10800
setstate Brunnen 2020-01-01 16:29:10 SetCmdOff set shelly05 off 0
setstate Brunnen 2020-01-01 16:29:24 SetCmdOn set shelly05 on 0
setstate Brunnen 2020-09-13 15:07:03 TimeEnd 09:00
setstate Brunnen 2019-10-28 09:13:30 TimeStart 09:00
setstate Brunnen 2020-09-21 16:50:48 state off
</syntaxhighlight>
==== RAW Definition Brunnen_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Brunnen_Counter:pulseTimePerDay] >= [Brunnen:RunTimePerDay] and\
[Brunnen_Counter:pulseTimeIncrement] >= [Brunnen:RunTimeMin] and\
[Brunnen:state] eq "on" and [Brunnen:Brunnen_Button] eq "off" )\
\
({Log 3, "Brunnen cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn der Brunnen bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Brunnen cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Brunnen:PowerLimitOff] and\
[Brunnen_PV:wait_timer] ne "no timer" and\
[Brunnen_PV:wait_timer] ne "" and\
[Brunnen:state] eq "off" )\
\
({Log 3, "Brunnen cmd_3 : Brunnen stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
## Dies ist beim Brunnen nicht aktiv, um eine Überschwemmung zu vermeiden\
## Es wird nur eine log Meldung geschrieben\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Brunnen:PowerLimitOn] and\
[Brunnen:state] eq "off" and\
[[Brunnen:TimeStart]-[Brunnen:TimeEnd]] and\
[Brunnen_Counter:pulseTimePerDay] < [Brunnen:RunTimePerDay] )\
\
({Log 3, "Brunnen cmd_4 : Brunnen freigabe"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose kann eingeschaltet werden")}\
## {fhem("set Brunnen on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Brunnens einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Brunnen cmd_5 : Brunnen manuell ein"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOn",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist eingeschaltet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 6 Steckdose des Brunnen manuell abschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Brunnen cmd_6 : Brunnen manuell aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
{fhem("set Brunnen off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn die Brunnenpumpe läuft\
##\
DOELSEIF\
([shelly05:power_0] > 600 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Brunnen cmd_7 : Brunnenpumpe läuft"}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe gestartet")}\
{fhem("set Brunnen on")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Brunnenpumpe durch Druckschalter abschaltet\
##\
DOELSEIF\
([shelly05:power_0] == 0 )\
\
({Log 3, "Brunnen cmd_8 : Brunnenpumpe aus"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Brunnenpumpe abgeschaltet")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn der Brunnen nicht gebraucht wird\
##\
DOELSEIF\
([[Brunnen:TimeEnd]-[Brunnen:TimeStart]] and\
([Brunnen:state] eq "on" or [shelly05:relay_0] eq "on") )\
\
({Log 3, "Brunnen cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Brunnen","SetCmdOff",0))}\
{fhem("set Brunnen off")}\
{fhem("setreading Brunnen Brunnen_Button off")}\
{fhem("setreading Brunnen_PV Brunnen_Status Steckdose ist ausgeschaltet")}\
)
attr Brunnen_PV DbLogExclude .*
attr Brunnen_PV DbLogInclude state,STATE,cmd.*,Device,Brunnen_Status,wait_timer
attr Brunnen_PV alias Brunnen_PV
attr Brunnen_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Brunnen manuell ein|Brunnen manuell aus|Brunnen laeuft|Brunnen aus|Eigenverbrauch gesperrt
attr Brunnen_PV comment Version 2020.10.19 18:28
attr Brunnen_PV do always
attr Brunnen_PV group PV Eigenverbrauch-Steuerung
attr Brunnen_PV icon well
attr Brunnen_PV room Strom->Photovoltaik
attr Brunnen_PV sortby 31
attr Brunnen_PV stateFormat state : Brunnen_Status
attr Brunnen_PV verbose 0
attr Brunnen_PV wait 0:0:0:[Brunnen:PowerLevelMinTime]:0:30:0:60:0
</syntaxhighlight>
==== RAW Definition Brunnen_Signale (Shelly Modul: shelly2.5) ====
Die Einschaltung der Brunnenpumpe erfolgt mit Relais 1 . Am Shelly2.5 ist auch ein Taster verdrahtet, über den die Pumpe vor Ort aktiviert werden kann.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Brunnen_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Brunnen_Counter HourCounter shelly05:power_0:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_0:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Brunnen_Counter DbLogExclude .*
attr Brunnen_Counter alias Brunnen_Counter
attr Brunnen_Counter comment Version 2020.10.19 18:28\
On und Off des Pools werden direkt über den Shelly Stromverbrauch getriggert.
attr Brunnen_Counter event-on-change-reading .*
attr Brunnen_Counter group PV Eigenverbrauch-Steuerung
attr Brunnen_Counter icon time_timer
attr Brunnen_Counter interval 5
attr Brunnen_Counter room Strom->Photovoltaik
attr Brunnen_Counter sortby 33
attr Brunnen_Counter verbose 0
</syntaxhighlight>

=== Beispiel Akku laden ===
In diesem Beispiel wird der Akku eines Rasenroboters und in unserem Fall auch des E-Bikes an einer Steckdose geladen. Ziel ist es auch über den Winter immer wieder die Akkus am Leben zu erhalten.
==== RAW Definition Shaun (dummy Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun dummy
attr Shaun DbLogExclude .*
attr Shaun DbLogInclude state
attr Shaun alias Shaun
attr Shaun comment Version 2020.10.19 18:28
attr Shaun group PV Eigenverbrauch
attr Shaun icon scene_robo_lawnmower
attr Shaun readingList Shaun_Button PowerLevelMinTime PowerPhaseUse PowerLimitOn PowerLimitOff RunTimeMin RunTimePerDay SetCmdOff SetCmdOn TimeStart TimeEnd
attr Shaun room Strom->Photovoltaik
attr Shaun setList Shaun_Button:uzsuToggle,on,off PowerLevelMinTime:slider,30,30,300 PowerLimitOn:slider,250,250,2000 PowerLimitOff:slider,0,250,1000 RunTimeMin:slider,300,300,7200 RunTimePerDay:slider,7200,300,28800 SetCmdOff SetCmdOn TimeStart:time TimeEnd:time
attr Shaun sortby 14
attr Shaun stateFormat state
attr Shaun verbose 0
attr Shaun webCmd Shaun_Button

setstate Shaun off
setstate Shaun 2019-12-02 10:29:49 PowerLevelMinTime 300
setstate Shaun 2019-11-06 10:56:22 PowerLimitOff 100
setstate Shaun 2020-04-20 13:06:04 PowerLimitOn 300
setstate Shaun 2019-12-02 15:01:18 RunTimeMin 300
setstate Shaun 2020-04-02 13:59:34 RunTimePerDay 21600
setstate Shaun 2020-01-01 16:29:10 SetCmdOff set shelly05 off 1
setstate Shaun 2020-01-01 16:29:24 SetCmdOn set shelly05 on 1
setstate Shaun 2020-10-21 12:30:05 Shaun_Button off
setstate Shaun 2020-09-21 12:05:19 TimeEnd 15:00
setstate Shaun 2020-09-21 12:05:34 TimeStart 12:00
setstate Shaun 2020-10-21 14:00:38 state off
</syntaxhighlight>
==== RAW Definition Shaun_PV (DOIF Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_PV DOIF ################################################################################################################\
## 1 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und Maximallaufzeit pro Tag erreicht ist\
## jedoch nicht wenn manueller Betrieb aktiv ist.\
##\
([Shaun_Counter:pulseTimePerDay] >= [Shaun:RunTimePerDay] and\
[Shaun_Counter:pulseTimeIncrement] >= [Shaun:RunTimeMin] and\
[Shaun:state] eq "on" and [Shaun:Shaun_Button] eq "off" )\
\
({Log 3, "Shaun cmd_1 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 2 Eigenverbrauch sperren: wenn Mindestlaufzeit erreicht wurde und die PV-Produktion unter dem Mindestbedarf ist\
## ausser bei manuellem Einschalten und wenn das Shaun Laden bereits läuft\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" and [$SELF:cmd_nr] ne "7" )\
\
({Log 3, "Shaun cmd_2 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 3 Stop, wenn es nur ein kurzer Peak ist. Dieser Do Zweig setzt den wait timer vom Einschaltkommando cmd_4\
## wieder außer kraft, wenn während der Wartezeit die PV-Anlage zuwenig liefert.\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOff] and\
[Shaun_PV:wait_timer] ne "no timer" and\
[Shaun_PV:wait_timer] ne "" and\
[Shaun:state] eq "off" )\
\
({Log 3, "Shaun cmd_3 : Shaun stop wait timer"})\
################################################################################################################\
## 4 Eigenverbrauch freigeben: wenn PV-Produktion über dem Mindestbedarf ist und PV-Strom ins Netz eingespeist\
## wird und die Laufzeit pro Tag noch nicht erreicht ist\
##\
DOELSEIF\
([PV_1:Total_PV_Power_reserve] > [Shaun:PowerLimitOn] and\
[Shaun:state] eq "off" and\
[[Shaun:TimeStart]-[Shaun:TimeEnd]] and\
[Shaun_Counter:pulseTimePerDay] < [Shaun:RunTimePerDay] )\
\
({Log 3, "Shaun cmd_4 : Shaun freigabe"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 5 Steckdose manuell für die Benutzung des Shaun einschalten.\
##\
DOELSEIF\
([Brunnen:Brunnen_Button] eq "on" )\
\
({Log 3, "Shaun cmd_5 : Shaun manuell ein"}\
{fhem("".ReadingsVal("Shaun","SetCmdOn",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist eingeschaltet")}\
{fhem("set Shaun on")}\
)\
################################################################################################################\
## 6 Steckdose des Shaun manuell abschalten.\
##\
DOELSEIF\
([Shaun:Shaun_Button] eq "off" and\
([$SELF:cmd_nr] eq "5" or [$SELF:cmd_nr] eq "7") )\
\
({Log 3, "Shaun cmd_6 : Shaun manuell aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
{fhem("set Shaun off")}\
)\
################################################################################################################\
## 7 Statuswechsel wenn das Laden läuft\
##\
DOELSEIF\
([shelly05:power_1] > 15 and\
[$SELF:cmd_nr] ne "7")\
\
({Log 3, "Shaun cmd_7 : Shaun läuft"}\
{fhem("setreading Shaun_PV Shaun_Status Shaun wird geladen")}\
)\
################################################################################################################\
## 8 Abschalten der Steckdose wenn Shaun geladen ist\
##\
DOELSEIF\
([shelly05:power_1] <= 6 and\
[$SELF:cmd_nr] eq "7" )\
\
({Log 3, "Shaun cmd_8 : Shaun aus"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Shaun hat geladen")}\
)\
################################################################################################################\
## 9 Abschalten der Steckdose wenn es nicht mehr benötigt wird\
##\
DOELSEIF\
(([PV_1:Total_PV_Power_reserve] < [Shaun:PowerLimitOn] or\
[[Shaun:TimeEnd]-[Shaun:TimeStart]] ) and\
[Shaun:state] eq "on" and\
[$SELF:cmd_nr] ne "5" )\
\
({Log 3, "Shaun cmd_9 : Eigenverbrauch sperren"}\
{fhem("".ReadingsVal("Shaun","SetCmdOff",0))}\
{fhem("set Shaun off")}\
{fhem("setreading Shaun Shaun_Button off")}\
{fhem("setreading Shaun_PV Shaun_Status Steckdose ist ausgeschaltet")}\
)
attr Shaun_PV DbLogExclude .*
attr Shaun_PV DbLogInclude state,STATE,cmd.*,Device,Shaun_Status,wait_timer
attr Shaun_PV alias Shaun_PV
attr Shaun_PV cmdState Maximalzeit pro Tag überschritten|Eigenverbrauch gesperrt|Stop wait timer|Eigenverbrauch freigegeben|Shaun manuell ein|Shaun manuell aus|Shaun laed|Shaun aus|Eigenverbrauch gesperrt
attr Shaun_PV comment Version 2020.10.19 18:28
attr Shaun_PV do always
attr Shaun_PV group PV Eigenverbrauch-Steuerung
attr Shaun_PV icon scene_robo_lawnmower
attr Shaun_PV room Strom->Photovoltaik
attr Shaun_PV sortby 41
attr Shaun_PV stateFormat state : Shaun_Status
attr Shaun_PV verbose 0
attr Shaun_PV wait 0:0:0:[Shaun:PowerLevelMinTime]:0:30:0:60:30
</syntaxhighlight>
==== RAW Definition Shaun_Signale (Shelly Modul: shelly2.5) ====
Für die Ladung der Akkus wird hier das Relais 0 verwendet.
<syntaxhighlight lang="Perl">
defmod shelly05 Shelly <IP-Address>
attr shelly05 DbLogExclude .*
attr shelly05 DbLogInclude relay.*,power.*,energy.*
attr shelly05 alias Brunnen und Shaun
attr shelly05 comment Version 2020.10.19 18:28
attr shelly05 event-on-change-reading relay.*,power.*,energy.*,state,network
attr shelly05 group PV Eigenverbrauch-Steuerung
attr shelly05 icon taster_ch_1
attr shelly05 interval 60
attr shelly05 mode relay
attr shelly05 model shelly2.5
attr shelly05 room Shelly,Strom->Photovoltaik
attr shelly05 sortby 32
attr shelly05 stateFormat {sprintf("\
<TABLE>\
\
<TR>\
<TD VALIGN=\"TOP\" ALIGN=\"LEFT\" WIDTH=\"50\">\
Status: %s \
WebLink: %s\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"100\">\
Brunnen Gesamt 0: %08.2f KWh \
Shaun Gesamt 1: %08.2f KWh\
</TD>\
\
<TD VALIGN=\"TOP\" ALIGN=\"RIGHT\" WIDTH=\"70\">\
Relais 0: %s %06.1f Watt \
Relais 1: %s %06.1f Watt \
</TD>\
</TR>\
\
</TABLE>\
" ,\
(ReadingsVal($name,"state","none") eq "OK") ? "OK":"Error",\
ReadingsVal($name,"WebLink","none"),\
ReadingsVal($name,"energy_0",0)/1000,\
ReadingsVal($name,"energy_1",0)/1000,\
(ReadingsVal($name,"relay_0","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_0",0),\
(ReadingsVal($name,"relay_1","") eq "off") ? "off":"on",\
ReadingsVal($name,"power_1",0)\
)}
attr shelly05 userReadings WebLink:network { my $ip=ReadingsVal($NAME,"network","");; $ip =~ s/connected to //gs;; $ip =~ s/<[^>]*>//gs;; return("<html><a href='http://".$ip."/'>WEB</a></html>") }
attr shelly05 webCmd |
</syntaxhighlight>
==== RAW Definition Shaun_Counter (HourCounter Modul) ====
<syntaxhighlight lang="Perl">
defmod Shaun_Counter HourCounter shelly05:power_1:\s[0-9]{2,}(\.[0-9]{1,2})*$ shelly05:power_1:\s[0-9]{1}(\.[0-9]{1,2})*$
attr Shaun_Counter DbLogExclude .*
attr Shaun_Counter alias Shaun_Counter
attr Shaun_Counter comment Version 2020.10.19 18:28\
On und Off des Ladens werden direkt über den Shelly Stromverbrauch getriggert.
attr Shaun_Counter event-on-change-reading .*
attr Shaun_Counter group PV Eigenverbrauch-Steuerung
attr Shaun_Counter icon time_timer
attr Shaun_Counter interval 5
attr Shaun_Counter room Strom->Photovoltaik
attr Shaun_Counter sortby 43
attr Shaun_Counter verbose 0
</syntaxhighlight>

== Problemlösung ==
Hier könnt Ihr Eure Fragen loswerden.
* {{Link2Forum|Topic=114849|Message=0}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal Plenticore; KSEM; BYD HV)

== Projekte der FHEM-Community ==

* {{Link2Forum|Topic=102297|Message=958564}} - Photovoltaik mit Eigenverbrauch Steuerung (Kostal plenticore; EM410)
* {{Link2Forum|Topic=109875|Message=1038741}} - Kostal Plenticore Bilanz
* {{Link2Forum|Topic=108191|Message=1038741}} - Kostal Plenticore, EM410 (KSEM), BYD, Solarprognose, Forecast

* {{Link2Forum|Topic=53584}} - Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog)
* {{Link2Forum|Topic=45176}} - Neue Version von HTTPMOD mit neuen Features zum Testen

== Links ==

* [https://www.photovoltaikforum.com/thread/142261-programmatischer-lesender-und-schreibender-zugriff-auf-kostal-plenticore-z-b-min/?pageNo=1/ Zugriff mit Python auf den Plenticore]
* [https://www.photovoltaikforum.com/thread/144350-kostenlose-wetterprognose-pv-prognose-ertragsprogonse-mit-st%C3%BCndlicher-aufl%C3%B6sung/?pageNo=1/ Ertragsprognose mit DWD]
* [https://www.photovoltaikforum.com/thread/146383-eigenverbrauchssteuerung-verh%C3%A4lt-sich-mit-speicher-anders-als-ohne/?pageNo=1/ Eigenverbrauchssteuerung beim Plenticore]
* [https://github.com/kilianknoll/ Github Kilian DWD Forecast]
* [https://github.com/FL550/ Github FL550 DWD Forecast]
* [https://svn.fhem.de/fhem/trunk/fhem/contrib/ch.eick/ contrib/ch.eick]

[[Kategorie:IP Components]]
[[Kategorie:Wechselrichter]]
[[Kategorie:Wallboxen]]