};
return $ctable;
}
################################################################
# Werte aktuelle Stunde für forecastGraphic
################################################################
sub _beamGraphicFirstHour {
my $paref = shift;
my $hash = $paref->{hash};
my $hfcg = $paref->{hfcg};
my $offset = $paref->{offset};
my $hourstyle = $paref->{hourstyle};
my $beam1cont = $paref->{beam1cont};
my $beam2cont = $paref->{beam2cont};
my $day;
my $t = NexthoursVal ($hash, "NextHour00", "starttime", '0000-00-00 24');
my ($year,$month,$day_str,$thishour) = $t =~ m/(\d{4})-(\d{2})-(\d{2})\s(\d{2})/x;
my ($val1,$val2,$val3,$val4) = (0,0,0,0);
$thishour++;
$hfcg->{0}{time_str} = $thishour;
$thishour = int($thishour); # keine führende Null
$hfcg->{0}{time} = $thishour;
$hfcg->{0}{day_str} = $day_str;
$day = int($day_str);
$hfcg->{0}{day} = $day;
$hfcg->{0}{mktime} = fhemTimeLocal(0,0,$thishour,$day,int($month)-1,$year-1900); # gleich die Unix Zeit dazu holen
if ($offset) {
$hfcg->{0}{time} += $offset;
if ($hfcg->{0}{time} < 0) {
$hfcg->{0}{time} += 24;
my $n_day = strftime "%d", localtime($hfcg->{0}{mktime} - (3600 * abs($offset))); # Achtung : Tageswechsel - day muss jetzt neu berechnet werden !
$hfcg->{0}{day} = int($n_day);
$hfcg->{0}{day_str} = $n_day;
}
$hfcg->{0}{time_str} = sprintf('%02d', $hfcg->{0}{time});
$val1 = HistoryVal ($hash, $hfcg->{0}{day_str}, $hfcg->{0}{time_str}, "pvfc", 0);
$val2 = HistoryVal ($hash, $hfcg->{0}{day_str}, $hfcg->{0}{time_str}, "pvrl", 0);
$val3 = HistoryVal ($hash, $hfcg->{0}{day_str}, $hfcg->{0}{time_str}, "gcons", 0);
$val4 = HistoryVal ($hash, $hfcg->{0}{day_str}, $hfcg->{0}{time_str}, "confc", 0);
# $hfcg->{0}{weather} = CircularVal ($hash, $hfcg->{0}{time_str}, "weatherid", undef);
$hfcg->{0}{weather} = HistoryVal ($hash, $hfcg->{0}{day_str}, $hfcg->{0}{time_str}, "weatherid", undef);
}
else {
$val1 = CircularVal ($hash, $hfcg->{0}{time_str}, "pvfc", 0);
$val2 = CircularVal ($hash, $hfcg->{0}{time_str}, "pvrl", 0);
$val3 = CircularVal ($hash, $hfcg->{0}{time_str}, "gcons", 0);
$val4 = CircularVal ($hash, $hfcg->{0}{time_str}, "confc", 0);
$hfcg->{0}{weather} = CircularVal ($hash, $hfcg->{0}{time_str}, "weatherid", undef);
#$val4 = (ReadingsVal($name,"ThisHour_IsConsumptionRecommended",'no') eq 'yes' ) ? $icon : undef;
}
$hfcg->{0}{time_str} = sprintf('%02d', $hfcg->{0}{time}-1).$hourstyle;
$hfcg->{0}{beam1} = ($beam1cont eq 'pvForecast') ? $val1 : ($beam1cont eq 'pvReal') ? $val2 : ($beam1cont eq 'gridconsumption') ? $val3 : $val4;
$hfcg->{0}{beam2} = ($beam2cont eq 'pvForecast') ? $val1 : ($beam2cont eq 'pvReal') ? $val2 : ($beam2cont eq 'gridconsumption') ? $val3 : $val4;
$hfcg->{0}{diff} = $hfcg->{0}{beam1} - $hfcg->{0}{beam2};
return ($thishour);
}
################################################################
# Werte restliche Stunden für forecastGraphic
################################################################
sub _beamGraphicRemainingHours {
my $paref = shift;
my $hash = $paref->{hash};
my $hfcg = $paref->{hfcg};
my $offset = $paref->{offset};
my $maxhours = $paref->{maxhours};
my $hourstyle = $paref->{hourstyle};
my $beam1cont = $paref->{beam1cont};
my $beam2cont = $paref->{beam2cont};
my $maxVal = $paref->{maxVal}; # dyn. Anpassung der Balkenhöhe oder statisch ?
$maxVal //= $hfcg->{0}{beam1}; # Startwert wenn kein Wert bereits via attr vorgegeben ist
my ($val1,$val2,$val3,$val4);
my $maxCon = $hfcg->{0}{beam1};
my $maxDif = $hfcg->{0}{diff}; # für Typ diff
my $minDif = $hfcg->{0}{diff}; # für Typ diff
for my $i (1..($maxhours*2)-1) { # doppelte Anzahl berechnen my $val1 = 0;
$val2 = 0;
$val3 = 0;
$val4 = 0;
$hfcg->{$i}{time} = $hfcg->{0}{time} + $i;
while ($hfcg->{$i}{time} > 24) {
$hfcg->{$i}{time} -= 24; # wird bis zu 2x durchlaufen
}
$hfcg->{$i}{time_str} = sprintf('%02d', $hfcg->{$i}{time});
my $nh; # next hour
if ($offset < 0) {
if ($i <= abs($offset)) { # $daystr stimmt nur nach Mitternacht, vor Mitternacht muß $hfcg->{0}{day_str} als Basis verwendet werden !
my $ds = strftime "%d", localtime($hfcg->{0}{mktime} - (3600 * abs($offset+$i))); # V0.49.4
# Sonderfall Mitternacht
$ds = strftime "%d", localtime($hfcg->{0}{mktime} - (3600 * (abs($offset-$i+1)))) if ($hfcg->{$i}{time} == 24); # V0.49.4
$val1 = HistoryVal ($hash, $ds, $hfcg->{$i}{time_str}, "pvfc", 0);
$val2 = HistoryVal ($hash, $ds, $hfcg->{$i}{time_str}, "pvrl", 0);
$val3 = HistoryVal ($hash, $ds, $hfcg->{$i}{time_str}, "gcons", 0);
$val4 = HistoryVal ($hash, $ds, $hfcg->{$i}{time_str}, "confc", 0);
$hfcg->{$i}{weather} = HistoryVal ($hash, $ds, $hfcg->{$i}{time_str}, "weatherid", undef);
}
else {
$nh = sprintf('%02d', $i+$offset);
}
}
else {
$nh = sprintf('%02d', $i);
}
if (defined($nh)) {
$val1 = NexthoursVal ($hash, 'NextHour'.$nh, "pvforecast", 0);
$val4 = NexthoursVal ($hash, 'NextHour'.$nh, "confc", 0);
$hfcg->{$i}{weather} = NexthoursVal ($hash, 'NextHour'.$nh, "weatherid", undef);
#$val4 = (ReadingsVal($name,"NextHour".$ii."_IsConsumptionRecommended",'no') eq 'yes') ? $icon : undef;
}
$hfcg->{$i}{time_str} = sprintf('%02d', $hfcg->{$i}{time}-1).$hourstyle;
$hfcg->{$i}{beam1} = ($beam1cont eq 'pvForecast') ? $val1 : ($beam1cont eq 'pvReal') ? $val2 : ($beam1cont eq 'gridconsumption') ? $val3 : $val4;
$hfcg->{$i}{beam2} = ($beam2cont eq 'pvForecast') ? $val1 : ($beam2cont eq 'pvReal') ? $val2 : ($beam2cont eq 'gridconsumption') ? $val3 : $val4;
# sicher stellen das wir keine undefs in der Liste haben !
$hfcg->{$i}{beam1} //= 0;
$hfcg->{$i}{beam2} //= 0;
$hfcg->{$i}{diff} = $hfcg->{$i}{beam1} - $hfcg->{$i}{beam2};
$maxVal = $hfcg->{$i}{beam1} if ($hfcg->{$i}{beam1} > $maxVal);
$maxCon = $hfcg->{$i}{beam2} if ($hfcg->{$i}{beam2} > $maxCon);
$maxDif = $hfcg->{$i}{diff} if ($hfcg->{$i}{diff} > $maxDif);
$minDif = $hfcg->{$i}{diff} if ($hfcg->{$i}{diff} < $minDif);
}
my $back = {
maxVal => $maxVal,
maxCon => $maxCon,
maxDif => $maxDif,
minDif => $minDif,
};
return ($back);
}
################################################################
# Balkenausgabe für forecastGraphic
################################################################
sub _beamGraphic {
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $hfcg = $paref->{hfcg};
my $maxhours = $paref->{maxhours};
my $weather = $paref->{weather};
my $show_night = $paref->{show_night}; # alle Balken (Spalten) anzeigen ?
my $show_diff = $paref->{show_diff}; # zusätzliche Anzeige $di{} in allen Typen
my $lotype = $paref->{lotype};
my $height = $paref->{height};
my $fsize = $paref->{fsize};
my $kw = $paref->{kw};
my $colorfc = $paref->{colorfc};
my $colorc = $paref->{colorc};
my $fcolor1 = $paref->{fcolor1};
my $fcolor2 = $paref->{fcolor2};
my $offset = $paref->{offset};
my $thishour = $paref->{thishour};
my $maxVal = $paref->{maxVal};
my $maxCon = $paref->{maxCon};
my $maxDif = $paref->{maxDif};
my $minDif = $paref->{minDif};
my $beam1cont = $paref->{beam1cont};
my $beam2cont = $paref->{beam2cont};
$lotype = 'single' if ($beam1cont eq $beam2cont); # User Auswahl Layout überschreiben bei gleichen Beamcontent !
# Wenn Table class=block alleine steht, zieht es bei manchen Styles die Ausgabe auf 100% Seitenbreite
# lässt sich durch einbetten in eine zusätzliche Table roomoverview eindämmen
# Die Tabelle ist recht schmal angelegt, aber nur so lassen sich Umbrüche erzwingen
my ($val,$z2,$z3,$z4,$he);
my $ret;
$ret .= __weatherOnBeam ($paref);
my $m = $paref->{modulo} % 2;
if($show_diff eq 'top') { # Zusätzliche Zeile Ertrag - Verbrauch
$ret .= "
";
my $ii;
for my $i (0..($maxhours*2)-1) { # gleiche Bedingung wie oben
next if (!$show_night && ($hfcg->{$i}{weather} > 99)
&& !$hfcg->{$i}{beam1}
&& !$hfcg->{$i}{beam2});
$ii++; # wieviele Stunden haben wir bisher angezeigt ?
last if ($ii > $maxhours); # vorzeitiger Abbruch
$val = formatVal6($hfcg->{$i}{diff},$kw,$hfcg->{$i}{weather});
$val = $hfcg->{$i}{diff} < 0 ?
''.$val.'' :
$val > 0 ?
'+'.$val :
$val; # negative Zahlen in Fettschrift, 0 aber ohne +
$ret .= "
$val
";
}
$ret .= "
"; # freier Platz am Ende
}
$ret .= "
"; # Neue Zeile mit freiem Platz am Anfang
my $ii = 0;
for my $i (0..($maxhours*2)-1) { # gleiche Bedingung wie oben
next if (!$show_night && defined($hfcg->{$i}{weather})
&& ($hfcg->{$i}{weather} > 99)
&& !$hfcg->{$i}{beam1}
&& !$hfcg->{$i}{beam2});
$ii++;
last if ($ii > $maxhours);
# Achtung Falle, Division by Zero möglich,
# maxVal kann gerade bei kleineren maxhours Ausgaben in der Nacht leicht auf 0 fallen
$height = 200 if (!$height); # Fallback, sollte eigentlich nicht vorkommen, außer der User setzt es auf 0
$maxVal = 1 if (!int $maxVal);
$maxCon = 1 if (!$maxCon);
# Der zusätzliche Offset durch $fsize verhindert bei den meisten Skins
# dass die Grundlinie der Balken nach unten durchbrochen wird
if ($lotype eq 'single') {
$he = int(($maxVal-$hfcg->{$i}{beam1}) / $maxVal*$height) + $fsize;
$z3 = int($height + $fsize - $he);
}
if ($lotype eq 'double') {
# Berechnung der Zonen
# he - freier der Raum über den Balken. fsize wird nicht verwendet, da bei diesem Typ keine Zahlen über den Balken stehen
# z2 - der Ertrag ggf mit Icon
# z3 - der Verbrauch , bei zu kleinem Wert wird der Platz komplett Zone 2 zugeschlagen und nicht angezeigt
# z2 und z3 nach Bedarf tauschen, wenn der Verbrauch größer als der Ertrag ist
$maxVal = $maxCon if ($maxCon > $maxVal); # wer hat den größten Wert ?
if ($hfcg->{$i}{beam1} > $hfcg->{$i}{beam2}) { # Beam1 oben , Beam2 unten
$z2 = $hfcg->{$i}{beam1}; $z3 = $hfcg->{$i}{beam2};
}
else { # tauschen, Verbrauch ist größer als Ertrag
$z3 = $hfcg->{$i}{beam1}; $z2 = $hfcg->{$i}{beam2};
}
$he = int(($maxVal-$z2)/$maxVal*$height);
$z2 = int(($z2 - $z3)/$maxVal*$height);
$z3 = int($height - $he - $z2); # was von maxVal noch übrig ist
if ($z3 < int($fsize/2)) { # dünnen Strichbalken vermeiden / ca. halbe Zeichenhöhe
$z2 += $z3;
$z3 = 0;
}
}
if ($lotype eq 'diff') {
# Berechnung der Zonen
# he - freier der Raum über den Balken , Zahl positiver Wert + fsize
# z2 - positiver Balken inkl Icon
# z3 - negativer Balken
# z4 - Zahl negativer Wert + fsize
my ($px_pos,$px_neg);
my $maxValBeam = 0; # ToDo: maxValBeam noch aus Attribut maxValBeam ableiten
if ($maxValBeam) { # Feste Aufteilung +/- , jeder 50 % bei maxValBeam = 0
$px_pos = int($height/2);
$px_neg = $height - $px_pos; # Rundungsfehler vermeiden
}
else { # Dynamische hoch/runter Verschiebung der Null-Linie
if ($minDif >= 0 ) { # keine negativen Balken vorhanden, die Positiven bekommen den gesammten Raum
$px_neg = 0;
$px_pos = $height;
}
else {
if ($maxDif > 0) {
$px_neg = int($height * abs($minDif) / ($maxDif + abs($minDif))); # Wieviel % entfallen auf unten ?
$px_pos = $height-$px_neg; # der Rest ist oben
}
else { # keine positiven Balken vorhanden, die Negativen bekommen den gesammten Raum
$px_neg = $height;
$px_pos = 0;
}
}
}
if ($hfcg->{$i}{diff} >= 0) { # Zone 2 & 3 mit ihren direkten Werten vorbesetzen
$z2 = $hfcg->{$i}{diff};
$z3 = abs($minDif);
}
else {
$z2 = $maxDif;
$z3 = abs($hfcg->{$i}{diff}); # Nur Betrag ohne Vorzeichen
}
# Alle vorbesetzen Werte umrechnen auf echte Ausgabe px
$he = (!$px_pos || !$maxDif) ? 0 : int(($maxDif-$z2)/$maxDif*$px_pos); # Teilung durch 0 vermeiden
$z2 = ($px_pos - $he) ;
$z4 = (!$px_neg || !$minDif) ? 0 : int((abs($minDif)-$z3)/abs($minDif)*$px_neg); # Teilung durch 0 unbedingt vermeiden
$z3 = ($px_neg - $z4);
# Beiden Zonen die Werte ausgeben könnten muß fsize als zusätzlicher Raum zugeschlagen werden !
$he += $fsize;
$z4 += $fsize if ($z3); # komplette Grafik ohne negativ Balken, keine Ausgabe von z3 & z4
}
# das style des nächsten TD bestimmt ganz wesentlich das gesammte Design
# das \n erleichtert das lesen des Seitenquelltext beim debugging
# vertical-align:bottom damit alle Balken und Ausgaben wirklich auf der gleichen Grundlinie sitzen
$ret .="
"; # mit width=100% etwas bessere Füllung der Balken
$ret .="
";
$ret .="
".$val.'
';
if ($hfcg->{$i}{beam1} || $show_night) { # Balken nur einfärben wenn der User via Attr eine Farbe vorgibt, sonst bestimmt class odd von TR alleine die Farbe
my $style = "style=\"padding-bottom:0px; vertical-align:top; margin-left:auto; margin-right:auto;";
$style .= defined $colorfc ? " background-color:#$colorfc\"" : '"'; # Syntaxhilight
$ret .= "
";
$ret .= "
";
my $sicon = 1;
#$ret .= $is{$i} if (defined ($is{$i}) && $sicon);
# inject the new icon if defined
##################################
#$ret .= consinject($hash,$i,@consumers) if($s);
$ret .= "
";
}
}
if ($lotype eq 'double') {
my ($color1, $color2, $style1, $style2, $v);
my $style = "style='padding-bottom:0px; padding-top:1px; vertical-align:top; margin-left:auto; margin-right:auto;";
$ret .="
\n"; # mit width=100% etwas bessere Füllung der Balken
# der Freiraum oben kann beim größten Balken ganz entfallen
$ret .="
" if ($he);
if($hfcg->{$i}{beam1} > $hfcg->{$i}{beam2}) { # wer ist oben, Beam2 oder Beam1 ? Wert und Farbe für Zone 2 & 3 vorbesetzen
$val = formatVal6($hfcg->{$i}{beam1},$kw,$hfcg->{$i}{weather});
$color1 = $colorfc;
$style1 = $style." background-color:#$color1; color:#$fcolor1;'";
if($z3) { # die Zuweisung können wir uns sparen wenn Zone 3 nachher eh nicht ausgegeben wird
$v = formatVal6($hfcg->{$i}{beam2},$kw,$hfcg->{$i}{weather});
$color2 = $colorc;
$style2 = $style." background-color:#$color2; color:#$fcolor2;'";
}
}
else {
$val = formatVal6($hfcg->{$i}{beam2},$kw,$hfcg->{$i}{weather});
$color1 = $colorc;
$style1 = $style." background-color:#$color1; color:#$fcolor2;'";
if($z3) {
$v = formatVal6($hfcg->{$i}{beam1},$kw,$hfcg->{$i}{weather});
$color2 = $colorfc;
$style2 = $style." background-color:#$color2; color:#$fcolor1;'";
}
}
$ret .= "
";
$ret .= "
$val";
# inject the new icon if defined
##################################
#$ret .= consinject($hash,$i,@consumers) if($s);
$ret .= "
";
if ($z3) { # die Zone 3 lassen wir bei zu kleinen Werten auch ganz weg
$ret .= "
";
$ret .= "
$v
";
}
}
if ($lotype eq 'diff') { # Type diff
my $style = "style='padding-bottom:0px; padding-top:1px; vertical-align:top; margin-left:auto; margin-right:auto;";
$ret .= "
\n"; # Tipp : das nachfolgende border=0 auf 1 setzen hilft sehr Ausgabefehler zu endecken
$val = ($hfcg->{$i}{diff} > 0) ? formatVal6($hfcg->{$i}{diff},$kw,$hfcg->{$i}{weather}) : '';
$val = ' 0 ' if ($hfcg->{$i}{diff} == 0); # Sonderfall , hier wird die 0 gebraucht !
if ($val) {
$ret .= "
";
}
else { # ohne Farbe
$z2 = 2 if ($hfcg->{$i}{diff} == 0); # Sonderfall, hier wird die 0 gebraucht !
if ($z2 && $val) { # z2 weglassen wenn nicht unbedigt nötig bzw. wenn zuvor he mit val keinen Wert hatte
$ret .= "
";
$ret .= "";
return $ret;
}
################################################################
# Wetter Icon Zeile
################################################################
sub __weatherOnBeam {
my $paref = shift;
my $name = $paref->{name};
my $hfcg = $paref->{hfcg};
my $maxhours = $paref->{maxhours};
my $weather = $paref->{weather};
my $show_night = $paref->{show_night}; # alle Balken (Spalten) anzeigen ?
my $colorw = $paref->{colorw}; # Wetter Icon Farbe
my $colorwn = $paref->{colorwn}; # Wetter Icon Farbe Nacht
my $width = $paref->{width};
my $ret = q{};
return $ret if(!$weather);
my $m = $paref->{modulo} % 2;
$ret .= "
"; # freier Platz am Anfang
my $ii;
for my $i (0..($maxhours*2)-1) {
last if (!exists($hfcg->{$i}{weather}));
next if (!$show_night && defined($hfcg->{$i}{weather})
&& ($hfcg->{$i}{weather} > 99)
&& !$hfcg->{$i}{beam1}
&& !$hfcg->{$i}{beam2});
# Lässt Nachticons aber noch durch wenn es einen Wert gibt , ToDo : klären ob die Nacht richtig gesetzt wurde
$ii++; # wieviele Stunden Icons haben wir bisher beechnet ?
last if ($ii > $maxhours);
# ToDo : weather_icon sollte im Fehlerfall Title mit der ID besetzen um in FHEMWEB sofort die ID sehen zu können
if (exists($hfcg->{$i}{weather}) && defined($hfcg->{$i}{weather})) {
my ($icon_name, $title) = $hfcg->{$i}{weather} > 100 ?
weather_icon($hfcg->{$i}{weather}-100) :
weather_icon($hfcg->{$i}{weather});
if($icon_name eq 'unknown') {
Log3 ($name, 4, "$name - unknown weather id: ".$hfcg->{$i}{weather}.", please inform the maintainer");
}
$icon_name .= $hfcg->{$i}{weather} < 100 ? '@'.$colorw : '@'.$colorwn;
my $val = FW_makeImage($icon_name) // q{};
if ($val eq $icon_name) { # passendes Icon beim User nicht vorhanden ! ( attr web iconPath falsch/prüfen/update ? )
$val = '???';
if(AttrVal ($name, "debug", 0)) { # nur für Debugging
Log (1, qq{DEBUG> $name - the icon "$weather_ids{$hfcg->{$i}{weather}}{icon}" not found. Please check attribute "iconPath" of your FHEMWEB instance and/or update your FHEM software});
}
}
$ret .= "
$val
";
}
else { # mit $hfcg->{$i}{weather} = undef kann man unten leicht feststellen ob für diese Spalte bereits ein Icon ausgegeben wurde oder nicht
$ret .= "
";
$hfcg->{$i}{weather} = undef; # ToDo : prüfen ob noch nötig
}
}
$ret .= "
"; # freier Platz am Ende der Icon Zeile
return $ret;
}
################################################################
# Energieflußgrafik
################################################################
sub _flowGraphic {
my $paref = shift;
my $name = $paref->{name};
my $flowgh = $paref->{flowgh};
my $flowgani = $paref->{flowgani};
my $css = $paref->{css};
my $style = 'width:'.$flowgh.'px; height:'.$flowgh.'px;';
my $fs = $flowgh < 300 ? '48px' : '32px';
my $animation = $flowgani ? '@keyframes dash { to { stroke-dashoffset: 0; } }' : ''; # Animation Ja/Nein
my $cpv = ReadingsNum($name, 'Current_PV', 0);
my $sun_color = $cpv ? 'flowg sun_active' : 'flowg sun_inactive';
my $cgc = ReadingsNum($name, 'Current_GridConsumption', 0);
my $cgc_style = $cgc ? 'flowg active_in' : 'flowg inactive_in';
my $cgfi = ReadingsNum($name, 'Current_GridFeedIn', 0);
my $cgfi_style = $cgfi ? 'flowg active_out' : 'flowg inactive_out';
my $csc = ReadingsNum($name, 'Current_SelfConsumption', 0);
my $csc_style = $csc ? 'flowg active_out' : 'flowg inactive_out';
my $batin = ReadingsNum($name, 'Current_PowerBatIn', undef);
my $batout = ReadingsNum($name, 'Current_PowerBatOut', undef);
my $soc = ReadingsNum($name, 'Current_BatCharge', 100);
my $bat_color = $soc < 26 ? 'flowg bat25' :
$soc < 76 ? 'flowg bat50' :
'flowg bat75';
my $hasbat = 1;
if (!defined($batin) && !defined($batout)) {
$hasbat = 0;
$batin = 0;
$batout = 0;
$soc = 0;
}
my $batin_style = $batin ? 'flowg active_out' : 'flowg inactive_out';
my $batout_style = $batout ? 'flowg active_in' : 'flowg inactive_in';
my $grid_color = $cgfi ? 'flowg grid_color1' : 'flowg grid_color2';
$grid_color = 'flowg grid_color3' if (!$cgfi && !$cgc && $batout); # dritte Farbe
my $ret = << "END0";
};
return $ret;
}
################################################################
# Inject consumer icon
################################################################
sub consinject {
my ($hash,$i,@consumers) = @_;
my $name = $hash->{NAME};
my $ret = "";
for (@consumers) {
if ($_) {
my ($cons,$im,$start,$end) = split (':', $_);
Log3 ($name, 4, "$name - Consumer to show -> $cons, relative to current time -> start: $start, end: $end") if($i<1);
if ($im && ($i >= $start) && ($i <= $end)) {
$ret .= FW_makeImage($im);
}
}
}
return $ret;
}
###############################################################################
# Balkenbreite normieren
#
# Die Balkenbreite wird bestimmt durch den Wert.
# Damit alle Balken die gleiche Breite bekommen, müssen die Werte auf
# 6 Ausgabezeichen angeglichen werden.
# "align=center" gleicht gleicht es aus, alternativ könnte man sie auch
# komplett rechtsbündig ausgeben.
# Es ergibt bei fast allen Styles gute Ergebnisse, Ausnahme IOS12 & 6, da diese
# beiden Styles einen recht großen Font benutzen.
# Wird Wetter benutzt, wird die Balkenbreite durch das Icon bestimmt
#
###############################################################################
sub formatVal6 {
my ($v,$kw,$w) = @_;
my $n = ' '; # positive Zahl
if($v < 0) {
$n = '-'; # negatives Vorzeichen merken
$v = abs($v);
}
if($kw eq 'kWh') { # bei Anzeige in kWh muss weniger aufgefüllt werden
$v = sprintf('%.1f',($v/1000));
$v += 0; # keine 0.0 oder 6.0 etc
return ($n eq '-') ? ($v*-1) : $v if defined($w) ;
my $t = $v - int($v); # Nachkommstelle ?
if(!$t) { # glatte Zahl ohne Nachkommastelle
if(!$v) {
return ' '; # 0 nicht anzeigen, passt eigentlich immer bis auf einen Fall im Typ diff
}
elsif ($v < 10) {
return ' '.$n.$v.' ';
}
else {
return ' '.$n.$v.' ';
}
}
else { # mit Nachkommastelle -> zwei Zeichen mehr .X
if ($v < 10) {
return ' '.$n.$v.' ';
}
else {
return $n.$v.' ';
}
}
}
return ($n eq '-') ? ($v*-1) : $v if defined($w);
# Werte bleiben in Watt
if (!$v) { return ' '; } ## no critic "Cascading" # keine Anzeige bei Null
elsif ($v < 10) { return ' '.$n.$v.' '; } # z.B. 0
elsif ($v < 100) { return ' '.$n.$v.' '; }
elsif ($v < 1000) { return ' '.$n.$v.' '; }
elsif ($v < 10000) { return $n.$v.' '; }
else { return $n.$v; } # mehr als 10.000 W :)
}
###############################################################################
# Zuordungstabelle "WeatherId" angepasst auf FHEM Icons
###############################################################################
sub weather_icon {
my $id = shift;
$id = int $id;
my $lang = AttrVal ("global", "language", "EN");
my $txt = $lang eq "DE" ? "txtd" : "txte";
if(defined $weather_ids{$id}) {
return $weather_ids{$id}{icon}, encode("utf8", $weather_ids{$id}{$txt});
}
return 'unknown','';
}
################################################################
# benötigte Attribute im DWD Device checken
################################################################
sub checkdwdattr {
my $name = shift;
my $dwddev = shift;
my $amref = shift;
my @fcprop = map { trim($_) } split ",", AttrVal($dwddev, "forecastProperties", "pattern");
my $fcr = AttrVal($dwddev, "forecastResolution", 3);
my $err;
my @aneeded;
for my $am (@$amref) {
next if($am ~~ @fcprop);
push @aneeded, $am;
}
if (@aneeded) {
$err = qq{ERROR - device "$dwddev" -> attribute "forecastProperties" must contain: }.join ",",@aneeded;
}
if($fcr != 1) {
$err .= ", " if($err);
$err .= qq{ERROR - device "$dwddev" -> attribute "forecastResolution" must be set to "1"};
}
Log3 ($name, 2, "$name - $err") if($err);
return $err;
}
################################################################
# ist Batterie installiert ?
# 1 - ja, 0 - nein
################################################################
sub useBattery {
my $name = shift;
my $badev = ReadingsVal($name, "currentBatteryDev", ""); # aktuelles Meter device für Batteriewerte
my ($a,$h) = parseParams ($badev);
$badev = $a->[0] // "";
return if(!$badev || !$defs{$badev});
return ($badev, $a ,$h);
}
################################################################
# wird PV Autokorrektur verwendet ?
# 1 - ja, 0 - nein
################################################################
sub useAutoCorrection {
my $name = shift;
my $dcauto = ReadingsVal ($name, 'pvCorrectionFactor_Auto', 'off');
return 1 if($dcauto eq 'on');
return;
}
################################################################
# Ist Attribut 'numHistDays' gesetzt ?
# $usenhd: 1 - ja, 0 - nein
# $nhd : Anzahl der zu verwendenden HistDays
################################################################
sub useNumHistDays {
my $name = shift;
my $usenhd = 0;
my $nhd = AttrVal($name, 'numHistDays', $calcmaxd+1);
if($nhd == $calcmaxd+1) {
$nhd = $calcmaxd;
}
else {
$usenhd = 1;
}
return ($usenhd, $nhd);
}
##################################################################################################
# PV Forecast Rad1h in kWh / Wh
# Berechnung nach Formel 1 aus http://www.ing-büro-junge.de/html/photovoltaik.html:
#
# * Faktor für Umwandlung kJ in kWh: 0.00027778
# * Eigene Modulfläche in qm z.B.: 31,04
# * Wirkungsgrad der Module in % z.B.: 16,52
# * Wirkungsgrad WR in % z.B.: 98,3
# * Korrekturwerte wegen Ausrichtung/Verschattung etc.
#
# Die Formel wäre dann:
# Ertrag in Wh = Rad1h * 0.00027778 * 31,04 qm * 16,52% * 98,3% * 100% * 1000
#
# Berechnung nach Formel 2 aus http://www.ing-büro-junge.de/html/photovoltaik.html:
#
# * Globalstrahlung: G = kJ / m2
# * Korrektur mit Flächenfaktor f: Gk = G * f
# * Globalstrahlung (STC): 1 kW/m2
# * Peak Leistung String (kWp): Pnenn = x kW
# * Performance Ratio: PR (typisch 0,85 bis 0,9)
# * weitere Korrekturwerte für Regen, Wolken etc.: Korr
#
# pv (kWh) = G * f * 0.00027778 (kWh/m2) / 1 kW/m2 * Pnenn (kW) * PR * Korr
# pv (Wh) = G * f * 0.00027778 (kWh/m2) / 1 kW/m2 * Pnenn (kW) * PR * Korr * 1000
#
# Die Abhängigkeit der Strahlungsleistung der Sonnenenergie nach Wetterlage und Jahreszeit ist
# hier beschrieben:
# https://www.energie-experten.org/erneuerbare-energien/photovoltaik/planung/sonnenstunden
#
# !!! PV Berechnungsgrundlagen !!!
# https://www.energie-experten.org/erneuerbare-energien/photovoltaik/planung/ertrag
# http://www.ing-büro-junge.de/html/photovoltaik.html
#
##################################################################################################
sub calcPVforecast {
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $rad = $paref->{rad}; # Nominale Strahlung aus DWD Device
my $num = $paref->{num}; # Nexthour
my $uac = $paref->{uac}; # Nutze Autokorrektur (on/off)
my $t = $paref->{t}; # aktueller Unix Timestamp
my $fh = $paref->{fh};
my $fd = $paref->{fd};
my $type = $hash->{TYPE};
my $stch = $data{$type}{$name}{strings}; # String Configuration Hash
my $pr = 1.0; # Performance Ratio (PR)
my $fh1 = $fh+1;
my $chour = strftime "%H", localtime($t+($num*3600)); # aktuelle Stunde
my $reld = $fd == 0 ? "today" : $fd == 1 ? "tomorrow" : "unknown";
my $pvcorr = ReadingsNum ($name, "pvCorrectionFactor_".sprintf("%02d",$fh+1), 1.00); # PV Korrekturfaktor (auto oder manuell)
my $hc = $pvcorr; # Voreinstellung RAW-Korrekturfaktor
my $hcfound = "use manual correction factor";
my $hq = "m";
my $clouddamp = AttrVal($name, "cloudFactorDamping", $cldampdef); # prozentuale Berücksichtigung des Bewölkungskorrekturfaktors
my $raindamp = AttrVal($name, "rainFactorDamping", $rdampdef); # prozentuale Berücksichtigung des Regenkorrekturfaktors
my @strings = sort keys %{$stch};
my $rainprob = NexthoursVal ($hash, "NextHour".sprintf("%02d",$num), "rainprob", 0); # Niederschlagswahrscheinlichkeit> 0,1 mm während der letzten Stunde
my $rcf = 1 - ((($rainprob - $rain_base)/100) * $raindamp/100); # Rain Correction Faktor mit Steilheit
my $cloudcover = NexthoursVal ($hash, "NextHour".sprintf("%02d",$num), "cloudcover", 0); # effektive Wolkendecke nächste Stunde X
my $ccf = 1 - ((($cloudcover - $cloud_base)/100) * $clouddamp/100); # Cloud Correction Faktor mit Steilheit und Fußpunkt
my $range = calcRange ($cloudcover); # V 0.50.1 # Range errechnen
## Ermitteln des relevanten Autokorrekturfaktors
if ($uac eq "on") { # Autokorrektur soll genutzt werden
$hcfound = "yes"; # Status ob Autokorrekturfaktor im Wertevorrat gefunden wurde
($hc, $hq) = CircularAutokorrVal ($hash, sprintf("%02d",$fh+1), $range, undef); # Korrekturfaktor/KF-Qualität der Stunde des Tages der entsprechenden Bewölkungsrange
$hq //= 0;
if (!defined $hc) {
$hcfound = "no";
$hc = 1; # keine Korrektur
$hq = 0;
}
}
$hc = sprintf "%.2f", $hc;
$data{$type}{$name}{nexthours}{"NextHour".sprintf("%02d",$num)}{pvcorrf} = $hc."/".$hq;
$data{$type}{$name}{nexthours}{"NextHour".sprintf("%02d",$num)}{cloudrange} = $range;
if($fd == 0 && $fh1) {
$paref->{pvcorrf} = $hc."/".$hq;
$paref->{nhour} = sprintf("%02d",$fh1);
$paref->{histname} = "pvcorrfactor";
setPVhistory ($paref);
delete $paref->{histname};
}
my $pvsum = 0;
my $peaksum = 0;
my ($lh,$sq);
for my $st (@strings) { # für jeden String der Config ..
my $peak = $stch->{"$st"}{peak}; # String Peak (kWp)
$peak *= 1000; # kWp in Wp umrechnen
my $ta = $stch->{"$st"}{tilt}; # Neigungswinkel Solarmodule
my $moddir = $stch->{"$st"}{dir}; # Ausrichtung der Solarmodule
my $af = $hff{$ta}{$moddir} / 100; # Flächenfaktor: http://www.ing-büro-junge.de/html/photovoltaik.html
my $pv = sprintf "%.1f", ($rad * $af * $kJtokWh * $peak * $pr * $ccf * $rcf);
$lh = { # Log-Hash zur Ausgabe
"moduleDirection" => $moddir,
"modulePeakString" => $peak." W",
"moduleTiltAngle" => $ta,
"Area factor" => $af,
"Cloudcover" => $cloudcover,
"CloudRange" => $range,
"CloudFactorDamping" => $clouddamp." %",
"Cloudfactor" => $ccf,
"Rainprob" => $rainprob,
"Rainfactor" => $rcf,
"RainFactorDamping" => $raindamp." %",
"Radiation" => $rad,
"Factor kJ to kWh" => $kJtokWh,
"PV generation forecast (raw)" => $pv." Wh"
};
$sq = q{};
for my $idx (sort keys %{$lh}) {
$sq .= $idx." => ".$lh->{$idx}."\n";
}
Log3 ($name, 4, "$name - PV forecast calc (raw) for $reld Hour ".sprintf("%02d",$chour+1)." string $st ->\n$sq");
$pvsum += $pv;
$peaksum += $peak;
}
$data{$type}{$name}{current}{allstringspeak} = $peaksum; # insgesamt installierte Peakleistung in W
$pvsum *= $hc; # Korrekturfaktor anwenden
$pvsum = $peaksum if($pvsum > $peaksum);
my $logao = qq{};
$paref->{pvsum} = $pvsum;
$paref->{peaksum} = $peaksum;
($pvsum, $logao) = _70percentRule ($paref);
$lh = { # Log-Hash zur Ausgabe
"CloudCorrFoundInStore" => $hcfound,
"PV correction factor" => $hc,
"PV correction quality" => $hq,
"PV generation forecast" => $pvsum." Wh ".$logao,
};
$sq = q{};
for my $idx (sort keys %{$lh}) {
$sq .= $idx." => ".$lh->{$idx}."\n";
}
Log3 ($name, 4, "$name - PV forecast calc for $reld Hour ".sprintf("%02d",$chour+1)." summary: \n$sq");
return $pvsum;
}
################################################################
# 70% Regel kalkulieren
################################################################
sub _70percentRule {
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $pvsum = $paref->{pvsum};
my $peaksum = $paref->{peaksum};
my $num = $paref->{num}; # Nexthour
my $logao = qq{};
my $confc = NexthoursVal ($hash, "NextHour".sprintf("%02d",$num), "confc", 0);
my $max70 = $peaksum/100 * 70;
if(AttrVal ($name, "follow70percentRule", "0") eq "1" && $pvsum > $max70) {
$pvsum = $max70;
$logao = qq{(reduced by 70 percent rule)};
}
if(AttrVal ($name, "follow70percentRule", "0") eq "dynamic" && $pvsum > $max70 + $confc) {
$pvsum = $max70 + $confc;
$logao = qq{(reduced by 70 percent dynamic rule)};
}
$pvsum = int $pvsum;
return ($pvsum, $logao);
}
################################################################
# Abweichung PVreal / PVforecast berechnen
# bei eingeschalteter automat. Korrektur
################################################################
sub calcVariance {
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $t = $paref->{t}; # aktuelle Unix-Zeit
my $chour = $paref->{chour};
my $day = $paref->{day}; # aktueller Tag (01,02,03...31)
return if(!useAutoCorrection ($name)); # nur bei "on" automatische Varianzkalkulation
my $idts = ReadingsTimestamp($name, "currentInverterDev", ""); # Definitionstimestamp des Inverterdevice
return if(!$idts);
$idts = timestringToTimestamp ($idts);
if($t - $idts < 7200) {
my $rmh = sprintf "%.1f", ((7200 - ($t - $idts)) / 3600);
Log3 ($name, 4, "$name - Variance calculation in standby. It starts in $rmh hours.");
readingsSingleUpdate($hash, "pvCorrectionFactor_Auto", "on (remains in standby for $rmh hours)", 0);
return;
}
else {
readingsSingleUpdate($hash, "pvCorrectionFactor_Auto", "on", 0);
}
my $maxvar = AttrVal($name, "maxVariancePerDay", $defmaxvar); # max. Korrekturvarianz
my @da;
for my $h (1..23) {
next if(!$chour || $h > $chour);
my $fcval = ReadingsNum ($name, "Today_Hour".sprintf("%02d",$h)."_PVforecast", 0);
next if(!$fcval);
my $pvval = ReadingsNum ($name, "Today_Hour".sprintf("%02d",$h)."_PVreal", 0);
next if(!$pvval);
my $cdone = ReadingsVal ($name, "pvCorrectionFactor_".sprintf("%02d",$h)."_autocalc", "");
if($cdone eq "done") {
Log3 ($name, 5, "$name - pvCorrectionFactor Hour: ".sprintf("%02d",$h)." already calculated");
next;
}
Log3 ($name, 5, "$name - Hour: ".sprintf("%02d",$h).", Today PVreal: $pvval, PVforecast: $fcval");
$paref->{hour} = $h;
my ($pvhis,$fchis,$dnum,$range) = calcAvgFromHistory ($paref); # historische PV / Forecast Vergleichswerte ermitteln
my ($oldfac, $oldq) = CircularAutokorrVal ($hash, sprintf("%02d",$h), $range, 0); # bisher definierter Korrekturfaktor/KF-Qualität der Stunde des Tages der entsprechenden Bewölkungsrange
$oldfac = 1 if(1*$oldfac == 0);
my $factor;
my ($usenhd) = useNumHistDays ($name); # ist Attr numHistDays gesetzt ?
if($dnum) { # Werte in History vorhanden -> haben Prio !
$dnum = $dnum + 1;
$pvval = ($pvval + $pvhis) / $dnum; # Ertrag aktuelle Stunde berücksichtigen
$fcval = ($fcval + $fchis) / $dnum; # Vorhersage aktuelle Stunde berücksichtigen
$factor = sprintf "%.2f", ($pvval / $fcval); # Faktorberechnung: reale PV / Prognose
}
elsif($oldfac && !$usenhd) { # keine Werte in History vorhanden, aber in CircularVal && keine Beschränkung durch Attr numHistDays
$dnum = $oldq + 1;
$factor = sprintf "%.2f", ($pvval / $fcval);
$factor = sprintf "%.2f", ($factor + $oldfac) / 2;
}
else { # ganz neuer Wert
$factor = sprintf "%.2f", ($pvval / $fcval);
$dnum = 1;
}
Log3 ($name, 4, "$name - variance -> range: $range, hour: $h, days: $dnum, real: $pvval, forecast: $fcval, factor: $factor");
if(abs($factor - $oldfac) > $maxvar) {
$factor = sprintf "%.2f", ($factor > $oldfac ? $oldfac + $maxvar : $oldfac - $maxvar);
Log3 ($name, 3, "$name - new limited Variance factor: $factor (old: $oldfac) for hour: $h");
}
else {
Log3 ($name, 3, "$name - new Variance factor: $factor (old: $oldfac) for hour: $h calculated") if($factor != $oldfac);
}
if(defined $range) {
my $type = $hash->{TYPE};
Log3 ($name, 5, "$name - write correction factor into circular Hash: Factor $factor, Hour $h, Range $range");
$data{$type}{$name}{circular}{sprintf("%02d",$h)}{pvcorrf}{$range} = $factor; # Korrekturfaktor für Bewölkung Range 0..10 für die jeweilige Stunde als Datenquelle eintragen
$data{$type}{$name}{circular}{sprintf("%02d",$h)}{quality}{$range} = $dnum; # Korrekturfaktor Qualität
}
else {
$range = "";
}
push @da, "pvCorrectionFactor_".sprintf("%02d",$h)."<>".$factor." (automatic - old factor: $oldfac, cloudiness range: $range, days in range: $dnum)";
push @da, "pvCorrectionFactor_".sprintf("%02d",$h)."_autocalc<>done";
}
createReadingsFromArray ($hash, \@da, 1);
return;
}
################################################################
# Berechne Durchschnitte PV Vorhersage / PV Ertrag
# aus Werten der PV History
################################################################
sub calcAvgFromHistory {
my $paref = shift;
my $hash = $paref->{hash};
my $hour = $paref->{hour}; # Stunde des Tages für die der Durchschnitt bestimmt werden soll
my $day = $paref->{day}; # aktueller Tag
$hour = sprintf("%02d",$hour);
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my $pvhh = $data{$type}{$name}{pvhist};
my ($usenhd, $calcd) = useNumHistDays ($name); # ist Attr numHistDays gesetzt ? und welcher Wert
my @k = sort {$a<=>$b} keys %{$pvhh};
my $ile = $#k; # Index letztes Arrayelement
my ($idx) = grep {$k[$_] eq "$day"} (0..@k-1); # Index des aktuellen Tages
if(defined $idx) {
my $ei = $idx-1;
$ei = $ei < 0 ? $ile : $ei;
my @efa;
for my $e (0..$calcmaxd) {
last if($e == $calcmaxd || $k[$ei] == $day);
unshift @efa, $k[$ei];
$ei--;
}
my $chwcc = HistoryVal ($hash, $day, $hour, "wcc", undef); # Wolkenbedeckung Heute & abgefragte Stunde
if(!defined $chwcc) {
Log3 ($name, 4, "$name - Day $day has no cloudiness value set for hour $hour, no past averages can be calculated.");
return;
}
my $range = calcRange ($chwcc); # V 0.50.1
if(scalar(@efa)) {
Log3 ($name, 4, "$name - PV History -> Raw Days ($calcmaxd) for average check: ".join " ",@efa);
}
else { # vermeide Fehler: Illegal division by zero
Log3 ($name, 4, "$name - PV History -> Day $day has index $idx. Use only current day for average calc");
return (undef,undef,undef,$range);
}
Log3 ($name, 4, "$name - cloudiness range of day/hour $day/$hour is: $range");
my $dnum = 0;
my ($pvrl,$pvfc) = (0,0);
for my $dayfa (@efa) {
my $histwcc = HistoryVal ($hash, $dayfa, $hour, "wcc", undef); # historische Wolkenbedeckung
if(!defined $histwcc) {
Log3 ($name, 4, "$name - PV History -> Day $dayfa has no cloudiness value set for hour $hour, this history dataset is ignored.");
next;
}
$histwcc = calcRange ($histwcc); # V 0.50.1
if($range == $histwcc) {
$pvrl += HistoryVal ($hash, $dayfa, $hour, "pvrl", 0);
$pvfc += HistoryVal ($hash, $dayfa, $hour, "pvfc", 0);
$dnum++;
Log3 ($name, 5, "$name - PV History -> historical Day/hour $dayfa/$hour included - cloudiness range: $range");
last if( $dnum == $calcd);
}
else {
Log3 ($name, 5, "$name - PV History -> current/historical cloudiness range different: $range/$histwcc Day/hour $dayfa/$hour discarded.");
}
}
if(!$dnum) {
Log3 ($name, 5, "$name - PV History -> all cloudiness ranges were different/not set -> no historical averages calculated");
return (undef,undef,undef,$range);
}
my $pvhis = sprintf "%.2f", $pvrl;
my $fchis = sprintf "%.2f", $pvfc;
Log3 ($name, 5, "$name - PV History -> Summary - cloudiness range: $range, days: $dnum, pvHist:$pvhis, fcHist:$fchis");
return ($pvhis,$fchis,$dnum,$range);
}
return;
}
################################################################
# Bewölkungs- bzw. Regenrange berechnen
################################################################
sub calcRange {
my $range = shift;
$range = sprintf("%.0f", $range/10);
return $range;
}
################################################################
# PV und PV Forecast in History-Hash speichern zur
# Berechnung des Korrekturfaktors über mehrere Tage
################################################################
sub setPVhistory {
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $t = $paref->{t}; # aktuelle Unix-Zeit
my $nhour = $paref->{nhour};
my $day = $paref->{day};
my $dayname = $paref->{dayname}; # aktueller Wochentagsname
my $histname = $paref->{histname} // qq{};
my $ethishour = $paref->{ethishour} // 0;
my $etotal = $paref->{etotal};
my $batinthishour = $paref->{batinthishour}; # Batterieladung in Stunde
my $btotin = $paref->{batintotal}; # totale Batterieladung
my $batoutthishour = $paref->{batoutthishour}; # Batterieentladung in Stunde
my $btotout = $paref->{batouttotal}; # totale Batterieentladung
my $calcpv = $paref->{calcpv} // 0;
my $gcthishour = $paref->{gctotthishour} // 0; # Netzbezug
my $fithishour = $paref->{gftotthishour} // 0; # Netzeinspeisung
my $con = $paref->{con} // 0; # realer Hausverbrauch Energie
my $confc = $paref->{confc} // 0; # Verbrauchsvorhersage
my $consumerco = $paref->{consumerco}; # Verbrauch eines Verbrauchers
my $wid = $paref->{wid} // -1;
my $wcc = $paref->{wcc} // 0; # Wolkenbedeckung
my $wrp = $paref->{wrp} // 0; # Wahrscheinlichkeit von Niederschlag
my $pvcorrf = $paref->{pvcorrf} // "1.00/0"; # pvCorrectionFactor
my $temp = $paref->{temp}; # Außentemperatur
my $type = $hash->{TYPE};
my $val = q{};
$data{$type}{$name}{pvhist}{$day}{99}{dayname} = $dayname;
if($histname eq "batinthishour") { # Batterieladung
$val = $batinthishour;
$data{$type}{$name}{pvhist}{$day}{$nhour}{batin} = $batinthishour;
my $batinsum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$batinsum += HistoryVal ($hash, $day, $k, "batin", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{batin} = $batinsum;
}
if($histname eq "batoutthishour") { # Batterieentladung
$val = $batoutthishour;
$data{$type}{$name}{pvhist}{$day}{$nhour}{batout} = $batoutthishour;
my $batoutsum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$batoutsum += HistoryVal ($hash, $day, $k, "batout", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{batout} = $batoutsum;
}
if($histname eq "pvrl") { # realer Energieertrag
$val = $ethishour;
$data{$type}{$name}{pvhist}{$day}{$nhour}{pvrl} = $ethishour;
my $pvrlsum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$pvrlsum += HistoryVal ($hash, $day, $k, "pvrl", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{pvrl} = $pvrlsum;
}
if($histname eq "pvfc") { # prognostizierter Energieertrag
$val = $calcpv;
$data{$type}{$name}{pvhist}{$day}{$nhour}{pvfc} = $calcpv;
my $pvfcsum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$pvfcsum += HistoryVal ($hash, $day, $k, "pvfc", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{pvfc} = $pvfcsum;
}
if($histname eq "confc") { # prognostizierter Hausverbrauch
$val = $confc;
$data{$type}{$name}{pvhist}{$day}{$nhour}{confc} = $confc;
my $confcsum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$confcsum += HistoryVal ($hash, $day, $k, "confc", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{confc} = $confcsum;
}
if($histname eq "cons") { # bezogene Energie
$val = $gcthishour;
$data{$type}{$name}{pvhist}{$day}{$nhour}{gcons} = $gcthishour;
my $gcsum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$gcsum += HistoryVal ($hash, $day, $k, "gcons", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{gcons} = $gcsum;
}
if($histname eq "gfeedin") { # eingespeiste Energie
$val = $fithishour;
$data{$type}{$name}{pvhist}{$day}{$nhour}{gfeedin} = $fithishour;
my $gfisum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$gfisum += HistoryVal ($hash, $day, $k, "gfeedin", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{gfeedin} = $gfisum;
}
if($histname eq "con") { # Energieverbrauch des Hauses
$val = $con;
$data{$type}{$name}{pvhist}{$day}{$nhour}{con} = $con;
my $consum = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
$consum += HistoryVal ($hash, $day, $k, "con", 0);
}
$data{$type}{$name}{pvhist}{$day}{99}{con} = $consum;
}
if($histname =~ /csm[et][0-9]+$/xs) { # Verbrauch eines Verbrauchers
$val = $consumerco;
$data{$type}{$name}{pvhist}{$day}{$nhour}{$histname} = $consumerco;
if($histname =~ /csme[0-9]+$/xs) {
my $sum = 0;
my $hours = 0;
for my $k (keys %{$data{$type}{$name}{pvhist}{$day}}) {
next if($k eq "99");
my $csme = HistoryVal ($hash, $day, $k, "$histname", 0);
next if(!$csme);
$sum += $csme;
$hours++;
}
$data{$type}{$name}{pvhist}{$day}{99}{$histname} = $sum;
$data{$type}{$name}{pvhist}{$day}{99}{"hours".$histname} = $hours;
}
}
if($histname eq "etotal") { # etotal des Wechselrichters
$val = $etotal;
$data{$type}{$name}{pvhist}{$day}{$nhour}{etotal} = $etotal;
$data{$type}{$name}{pvhist}{$day}{99}{etotal} = q{};
}
if($histname eq "batintotal") { # totale Batterieladung
$val = $btotin;
$data{$type}{$name}{pvhist}{$day}{$nhour}{batintotal} = $btotin;
$data{$type}{$name}{pvhist}{$day}{99}{batintotal} = q{};
}
if($histname eq "batouttotal") { # totale Batterieentladung
$val = $btotout;
$data{$type}{$name}{pvhist}{$day}{$nhour}{batouttotal} = $btotout;
$data{$type}{$name}{pvhist}{$day}{99}{batouttotal} = q{};
}
if($histname eq "weatherid") { # Wetter ID
$val = $wid;
$data{$type}{$name}{pvhist}{$day}{$nhour}{weatherid} = $wid;
$data{$type}{$name}{pvhist}{$day}{99}{weatherid} = q{};
}
if($histname eq "weathercloudcover") { # Wolkenbedeckung
$val = $wcc;
$data{$type}{$name}{pvhist}{$day}{$nhour}{wcc} = $wcc;
$data{$type}{$name}{pvhist}{$day}{99}{wcc} = q{};
}
if($histname eq "weatherrainprob") { # Niederschlagswahrscheinlichkeit
$val = $wrp;
$data{$type}{$name}{pvhist}{$day}{$nhour}{wrp} = $wrp;
$data{$type}{$name}{pvhist}{$day}{99}{wrp} = q{};
}
if($histname eq "pvcorrfactor") { # pvCorrectionFactor
$val = $pvcorrf;
$data{$type}{$name}{pvhist}{$day}{$nhour}{pvcorrf} = $pvcorrf;
$data{$type}{$name}{pvhist}{$day}{99}{pvcorrf} = q{};
}
if($histname eq "temperature") { # Außentemperatur
$val = $temp;
$data{$type}{$name}{pvhist}{$day}{$nhour}{temp} = $temp;
$data{$type}{$name}{pvhist}{$day}{99}{temp} = q{};
}
Log3 ($name, 5, "$name - set PV History day: $day, hour: $nhour, hash: $histname, val: $val");
return;
}
################################################################
# liefert aktuelle Einträge des in $htol
# angegebenen internen Hash
################################################################
sub listDataPool {
my $hash = shift;
my $htol = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my ($sq,$h);
my $sub = sub {
my $day = shift;
my $ret;
for my $key (sort{$a<=>$b} keys %{$h->{$day}}) {
my $pvrl = HistoryVal ($hash, $day, $key, "pvrl", "-");
my $pvfc = HistoryVal ($hash, $day, $key, "pvfc", "-");
my $gcon = HistoryVal ($hash, $day, $key, "gcons", "-");
my $con = HistoryVal ($hash, $day, $key, "con", "-");
my $confc = HistoryVal ($hash, $day, $key, "confc", "-");
my $gfeedin = HistoryVal ($hash, $day, $key, "gfeedin", "-");
my $wid = HistoryVal ($hash, $day, $key, "weatherid", "-");
my $wcc = HistoryVal ($hash, $day, $key, "wcc", "-");
my $wrp = HistoryVal ($hash, $day, $key, "wrp", "-");
my $temp = HistoryVal ($hash, $day, $key, "temp", undef);
my $pvcorrf = HistoryVal ($hash, $day, $key, "pvcorrf", "-");
my $dayname = HistoryVal ($hash, $day, $key, "dayname", undef);
my $etotal = HistoryVal ($hash, $day, $key, "etotal", "-");
my $btotin = HistoryVal ($hash, $day, $key, "batintotal", "-");
my $batin = HistoryVal ($hash, $day, $key, "batin", "-");
my $btotout = HistoryVal ($hash, $day, $key, "batouttotal", "-");
my $batout = HistoryVal ($hash, $day, $key, "batout", "-");
$ret .= "\n " if($ret);
$ret .= $key." => etotal: $etotal, pvfc: $pvfc, pvrl: $pvrl";
$ret .= "\n ";
$ret .= "confc: $confc, con: $con, gcon: $gcon, gfeedin: $gfeedin";
$ret .= "\n ";
$ret .= "batintotal: $btotin, batin: $batin, batouttotal: $btotout, batout: $batout";
$ret .= "\n ";
$ret .= "wid: $wid";
$ret .= ", wcc: $wcc";
$ret .= ", wrp: $wrp";
$ret .= ", temp: $temp" if($temp);
$ret .= ", pvcorrf: $pvcorrf";
$ret .= ", dayname: $dayname" if($dayname);
my $csm;
for my $c (1..$maxconsumer) {
$c = sprintf "%02d", $c;
my $csmt = HistoryVal ($hash, $day, $key, "csmt${c}", undef);
my $csme = HistoryVal ($hash, $day, $key, "csme${c}", undef);
my $csmh = HistoryVal ($hash, $day, $key, "hourscsme${c}", undef);
if(defined $csmt) {
$csm .= ", " if($csm);
$csm .= "csmt${c}: $csmt";
}
if(defined $csme) {
$csm .= ", " if($csm);
$csm .= "csme${c}: $csme";
}
if(defined $csmh) {
$csm .= ", " if($csm);
$csm .= "hourscsme${c}: $csmh";
}
}
if($csm) {
$ret .= "\n ";
$ret .= $csm;
}
}
return $ret;
};
if ($htol eq "pvhist") {
$h = $data{$type}{$name}{pvhist};
if (!keys %{$h}) {
return qq{PV cache is empty.};
}
for my $idx (sort{$a<=>$b} keys %{$h}) {
$sq .= $idx." => ".$sub->($idx)."\n";
}
}
if ($htol eq "consumer") {
$h = $data{$type}{$name}{consumers};
if (!keys %{$h}) {
return qq{Consumer cache is empty.};
}
for my $idx (sort{$a<=>$b} keys %{$h}) {
my $cret;
for my $ckey (sort keys %{$h->{$idx}}) {
if(ref $h->{$idx}{$ckey} eq "HASH") {
my $hk;
for my $f (sort {$a<=>$b} keys %{$h->{$idx}{$ckey}}) {
$hk .= " " if($hk);
$hk .= "$f=".$h->{$idx}{$ckey}{$f};
}
$cret .= $ckey." => ".$hk."\n ";
}
else {
$cret .= $ckey." => ".$h->{$idx}{$ckey}."\n ";
}
}
$sq .= $idx." => ".$cret."\n";
}
}
if ($htol eq "circular") {
$h = $data{$type}{$name}{circular};
if (!keys %{$h}) {
return qq{Circular cache is empty.};
}
for my $idx (sort keys %{$h}) {
my $pvfc = CircularVal ($hash, $idx, "pvfc", "-");
my $pvrl = CircularVal ($hash, $idx, "pvrl", "-");
my $confc = CircularVal ($hash, $idx, "confc", "-");
my $gcons = CircularVal ($hash, $idx, "gcons", "-");
my $gfeedin = CircularVal ($hash, $idx, "gfeedin", "-");
my $wid = CircularVal ($hash, $idx, "weatherid", "-");
my $wtxt = CircularVal ($hash, $idx, "weathertxt", "-");
my $wccv = CircularVal ($hash, $idx, "wcc", "-");
my $wrprb = CircularVal ($hash, $idx, "wrp", "-");
my $temp = CircularVal ($hash, $idx, "temp", "-");
my $pvcorrf = CircularVal ($hash, $idx, "pvcorrf", "-");
my $quality = CircularVal ($hash, $idx, "quality", "-");
my $batin = CircularVal ($hash, $idx, "batin", "-");
my $batout = CircularVal ($hash, $idx, "batout", "-");
my $pvcf;
if(ref $pvcorrf eq "HASH") {
for my $f (sort {$a<=>$b} keys %{$h->{$idx}{pvcorrf}}) {
$pvcf .= " " if($pvcf);
$pvcf .= "$f=".$h->{$idx}{pvcorrf}{$f};
}
}
else {
$pvcf = $pvcorrf;
}
my $cfq;
if(ref $quality eq "HASH") {
for my $q (sort {$a<=>$b} keys %{$h->{$idx}{quality}}) {
$cfq .= " " if($cfq);
$cfq .= "$q=".$h->{$idx}{quality}{$q};
}
}
else {
$cfq = $quality;
}
$sq .= "\n" if($sq);
$sq .= $idx." => pvfc: $pvfc, pvrl: $pvrl, batin: $batin, batout: $batout\n";
$sq .= " confc: $confc, gcon: $gcons, gfeedin: $gfeedin, wcc: $wccv, wrp: $wrprb\n";
$sq .= " temp: $temp, wid: $wid, wtxt: $wtxt\n";
$sq .= " corr: $pvcf\n";
$sq .= " quality: $cfq";
}
}
if ($htol eq "nexthours") {
$h = $data{$type}{$name}{nexthours};
if (!keys %{$h}) {
return qq{NextHours cache is empty.};
}
for my $idx (sort keys %{$h}) {
my $nhts = NexthoursVal ($hash, $idx, "starttime", "-");
my $today = NexthoursVal ($hash, $idx, "today", "-");
my $pvfc = NexthoursVal ($hash, $idx, "pvforecast", "-");
my $wid = NexthoursVal ($hash, $idx, "weatherid", "-");
my $neff = NexthoursVal ($hash, $idx, "cloudcover", "-");
my $crange = NexthoursVal ($hash, $idx, "cloudrange", "-");
my $r101 = NexthoursVal ($hash, $idx, "rainprob", "-");
my $rad1h = NexthoursVal ($hash, $idx, "Rad1h", "-");
my $pvcorrf = NexthoursVal ($hash, $idx, "pvcorrf", "-");
my $temp = NexthoursVal ($hash, $idx, "temp", "-");
my $confc = NexthoursVal ($hash, $idx, "confc", "-");
$sq .= "\n" if($sq);
$sq .= $idx." => starttime: $nhts, today: $today\n";
$sq .= " pvfc: $pvfc, confc: $confc, Rad1h: $rad1h\n";
$sq .= " wid: $wid, wcc: $neff, wrp: $r101, temp=$temp\n";
$sq .= " crange: $crange, correff: $pvcorrf";
}
}
if ($htol eq "qualities") {
$h = $data{$type}{$name}{nexthours};
if (!keys %{$h}) {
return qq{NextHours cache is empty.};
}
for my $idx (sort keys %{$h}) {
my $nhfc = NexthoursVal ($hash, $idx, "pvforecast", undef);
next if(!$nhfc);
my $nhts = NexthoursVal ($hash, $idx, "starttime", undef);
my $neff = NexthoursVal ($hash, $idx, "cloudcover", "-");
my $crange = NexthoursVal ($hash, $idx, "cloudrange", "-");
my $pvcorrf = NexthoursVal ($hash, $idx, "pvcorrf", "-/-");
my ($f,$q) = split "/", $pvcorrf;
$sq .= "\n" if($sq);
$sq .= "starttime: $nhts, wcc: $neff, crange: $crange, quality: $q, used factor: $f";
}
}
if ($htol eq "current") {
$h = $data{$type}{$name}{current};
if (!keys %{$h}) {
return qq{Current values cache is empty.};
}
for my $idx (sort keys %{$h}) {
if (ref $h->{$idx} ne "ARRAY") {
$sq .= $idx." => ".$h->{$idx}."\n";
}
else {
my $aser = join " ",@{$h->{$idx}};
$sq .= $idx." => ".$aser."\n";
}
}
}
return $sq;
}
################################################################
# liefert aktuelle Stringkonfiguration
# inkl. Vollständigkeitscheck
################################################################
sub checkStringConfig {
my $hash = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my $stch = $data{$type}{$name}{strings};
my $lang = AttrVal ("global", 'language', 'EN');
my $sub = sub {
my $string = shift;
my $ret;
for my $key (sort keys %{$stch->{"$string"}}) {
$ret .= ", " if($ret);
$ret .= $key.": ".$stch->{"$string"}{$key};
}
return $ret;
};
if (!keys %{$stch}) {
return qq{String configuration is empty.};
}
my $sc;
my $cf = 0;
for my $sn (sort keys %{$stch}) {
my $sp = $sn." => ".$sub->($sn)." ";
$cf = 1 if($sp !~ /dir.*?peak.*?tilt/x); # Test Vollständigkeit: z.B. Süddach => dir: S, peak: 5.13, tilt: 45
$sc .= $sp;
}
if($cf) {
$sc .= "
".encode ("utf8", $hqtxt{strok}{$lang});
}
return $sc;
}
################################################################
# Array auf eine festgelegte Anzahl Elemente beschränken,
# Das älteste Element wird entfernt
#
# $href = Referenz zum Array
# $limit = die Anzahl Elemente auf die gekürzt werden soll
# (default 3)
#
################################################################
sub limitArray {
my $href = shift;
my $limit = shift // 3;
return if(ref $href ne "ARRAY");
while (scalar @{$href} > $limit) {
shift @{$href};
}
return;
}
################################################################
# Timestrings berechnen
################################################################
sub timestampToTimestring {
my $epoch = shift;
my ($lyear,$lmonth,$lday,$lhour,$lmin,$lsec) = (localtime($epoch))[5,4,3,2,1,0];
my $ts;
$lyear += 1900; # year is 1900 based
$lmonth++; # month number is zero based
my ($sec,$min,$hour,$day,$mon,$year) = (localtime(time))[0,1,2,3,4,5]; # Standard f. z.B. Readingstimstamp
$year += 1900;
$mon++;
my $realts = sprintf("%04d-%02d-%02d %02d:%02d:%02d", $year,$mon,$day,$hour,$min,$sec);
my $tsdef = sprintf("%04d-%02d-%02d %02d:%s", $lyear,$lmonth,$lday,$lhour,"00:00"); # engl. Variante für Logging-Timestamps etc. (Minute/Sekunde == 00)
my $tsfull = sprintf("%04d-%02d-%02d %02d:%02d:%02d", $lyear,$lmonth,$lday,$lhour,$lmin,$lsec); # engl. Variante Vollzeit
if(AttrVal("global","language","EN") eq "DE") {
$ts = sprintf("%02d.%02d.%04d %02d:%s", $lday,$lmonth,$lyear,$lhour,"00:00");
}
else {
$ts = $tsdef;
}
return ($ts,$tsdef,$realts,$tsfull);
}
################################################################
# einen Zeitstring YYYY-MM-TT hh:mm:ss in einen Unix
# Timestamp umwandeln
################################################################
sub timestringToTimestamp {
my $tstring = shift;
my($y, $mo, $d, $h, $m, $s) = $tstring =~ /([0-9]{4})-([0-9]{2})-([0-9]{2})\s([0-9]{2}):([0-9]{2}):([0-9]{2})/xs;
return if(!$mo || !$y);
my $timestamp = fhemTimeLocal($s, $m, $h, $d, $mo-1, $y-1900);
return $timestamp;
}
################################################################
# Readings aus Array erstellen
# $daref: Referenz zum Array der zu erstellenden Readings
# muß Paare : enthalten
# $doevt: 1-Events erstellen, 0-keine Events erstellen
#
# readingsBulkUpdate($hash,$reading,$value,$changed,$timestamp)
#
################################################################
sub createReadingsFromArray {
my $hash = shift;
my $daref = shift;
my $doevt = shift // 0;
readingsBeginUpdate($hash);
for my $elem (@$daref) {
my ($rn,$rval,$ts) = split "<>", $elem, 3;
readingsBulkUpdate($hash, $rn, $rval, undef, $ts);
}
readingsEndUpdate($hash, $doevt);
return;
}
################################################################
# alle Readings eines Devices oder nur Reading-Regex
# löschen
################################################################
sub deleteReadingspec {
my $hash = shift;
my $spec = shift // ".*";
my $readingspec = '^'.$spec.'$';
for my $reading ( grep { /$readingspec/x } keys %{$hash->{READINGS}} ) {
readingsDelete($hash, $reading);
}
return;
}
######################################################################################
# NOTIFYDEV erstellen
######################################################################################
sub createNotifyDev {
my $hash = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
RemoveInternalTimer($hash, "FHEM::SolarForecast::createNotifyDev");
if($init_done == 1) {
my @nd;
my ($afc,$ara,$ain,$ame,$aba,$h);
my $fcdev = ReadingsVal($name, "currentForecastDev", ""); # Weather forecast Device
($afc,$h) = parseParams ($fcdev);
$fcdev = $afc->[0] // "";
my $radev = ReadingsVal($name, "currentRadiationDev", ""); # Radiation forecast Device
($ara,$h) = parseParams ($radev);
$radev = $ara->[0] // "";
my $indev = ReadingsVal($name, "currentInverterDev", ""); # Inverter Device
($ain,$h) = parseParams ($indev);
$indev = $ain->[0] // "";
my $medev = ReadingsVal($name, "currentMeterDev", ""); # Meter Device
($ame,$h) = parseParams ($medev);
$medev = $ame->[0] // "";
my $badev = ReadingsVal($name, "currentBatteryDev", ""); # Battery Device
($aba,$h) = parseParams ($badev);
$badev = $aba->[0] // "";
for my $c (sort{$a<=>$b} keys %{$data{$type}{$name}{consumers}}) { # Consumer Devices
my $codev = AttrVal($name, "consumer${c}", "");
my ($ac,$hc) = parseParams ($codev);
$codev = $ac->[0] // "";
push @nd, $codev if($codev);
}
push @nd, $fcdev;
push @nd, $radev if($radev ne $fcdev);
push @nd, $indev;
push @nd, $medev;
push @nd, $badev;
if(@nd) {
$hash->{NOTIFYDEV} = join ",", @nd;
readingsSingleUpdate ($hash, ".associatedWith", join(" ",@nd), 0);
}
}
else {
InternalTimer(gettimeofday()+3, "FHEM::SolarForecast::createNotifyDev", $hash, 0);
}
return;
}
################################################################
# Planungsdaten Consumer löschen
# $c - Consumer Nummer
################################################################
sub deleteConsumerPlanning {
my $hash = shift;
my $c = shift;
my $type = $hash->{TYPE};
my $name = $hash->{NAME};
delete $data{$type}{$name}{consumers}{$c}{planstate};
delete $data{$type}{$name}{consumers}{$c}{planswitchon};
delete $data{$type}{$name}{consumers}{$c}{planswitchoff};
deleteReadingspec ($hash, "consumer${c}.*" );
return;
}
###############################################################################
# Wert des pvhist-Hash zurückliefern
# Usage:
# HistoryVal ($hash, $day, $hod, $key, $def)
#
# $day: Tag des Monats (01,02,...,31)
# $hod: Stunde des Tages (01,02,...,24,99)
# $key: etotal - totale PV Erzeugung (Wh)
# pvrl - realer PV Ertrag
# pvfc - PV Vorhersage
# confc - Vorhersage Hausverbrauch (Wh)
# gcons - realer Netzbezug
# gfeedin - reale Netzeinspeisung
# batintotal - totale Batterieladung (Wh)
# batin - Batterieladung der Stunde (Wh)
# batouttotal - totale Batterieentladung (Wh)
# batout - Batterieentladung der Stunde (Wh)
# weatherid - Wetter ID
# wcc - Grad der Bewölkung
# temp - Außentemperatur
# wrp - Niederschlagswahrscheinlichkeit
# pvcorrf - PV Autokorrekturfaktor f. Stunde des Tages
# dayname - Tagesname (Kürzel)
# csmt${c} - Totalconsumption Consumer $c (1..$maxconsumer)
# csme${c} - Consumption Consumer $c (1..$maxconsumer) in $hod
# $def: Defaultwert
#
###############################################################################
sub HistoryVal {
my $hash = shift;
my $day = shift;
my $hod = shift;
my $key = shift;
my $def = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
if(defined($data{$type}{$name}{pvhist}) &&
defined($data{$type}{$name}{pvhist}{$day}) &&
defined($data{$type}{$name}{pvhist}{$day}{$hod}) &&
defined($data{$type}{$name}{pvhist}{$day}{$hod}{$key})) {
return $data{$type}{$name}{pvhist}{$day}{$hod}{$key};
}
return $def;
}
################################################################
# Wert des circular-Hash zurückliefern
# Achtung: die Werte im circular-Hash haben nicht
# zwingend eine Beziehung zueinander !!
#
# Usage:
# CircularVal ($hash, $hod, $key, $def)
#
# $hod: Stunde des Tages (01,02,...,24)
# $key: pvrl - realer PV Ertrag
# pvfc - PV Vorhersage
# confc - Vorhersage Hausverbrauch (Wh)
# gcons - realer Netzbezug
# gfeedin - reale Netzeinspeisung
# batin - Batterieladung (Wh)
# batout - Batterieentladung (Wh)
# weatherid - DWD Wetter id
# weathertxt - DWD Wetter Text
# wcc - DWD Wolkendichte
# wrp - DWD Regenwahrscheinlichkeit
# temp - Außentemperatur
# pvcorrf - PV Autokorrekturfaktoren (HASH)
# $def: Defaultwert
#
################################################################
sub CircularVal {
my $hash = shift;
my $hod = shift;
my $key = shift;
my $def = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
if(defined($data{$type}{$name}{circular}) &&
defined($data{$type}{$name}{circular}{$hod}) &&
defined($data{$type}{$name}{circular}{$hod}{$key})) {
return $data{$type}{$name}{circular}{$hod}{$key};
}
return $def;
}
################################################################
# Wert des Autokorrekturfaktors und dessen Qualität
# für eine bestimmte Bewölkungs-Range aus dem circular-Hash
# zurückliefern
# Usage:
# ($f,$q) = CircularAutokorrVal ($hash, $hod, $range, $def)
#
# $f: Korrekturfaktor f. Stunde des Tages
# $q: Qualität des Korrekturfaktors
#
# $hod: Stunde des Tages (01,02,...,24)
# $range: Range Bewölkung (1...10)
# $def: Defaultwert
#
################################################################
sub CircularAutokorrVal {
my $hash = shift;
my $hod = shift;
my $range = shift;
my $def = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my $pvcorrf = $def;
my $quality = $def;
if(defined($data{$type}{$name}{circular}) &&
defined($data{$type}{$name}{circular}{$hod}) &&
defined($data{$type}{$name}{circular}{$hod}{pvcorrf}) &&
defined($data{$type}{$name}{circular}{$hod}{pvcorrf}{$range})) {
$pvcorrf = $data{$type}{$name}{circular}{$hod}{pvcorrf}{$range};
}
if(defined($data{$type}{$name}{circular}) &&
defined($data{$type}{$name}{circular}{$hod}) &&
defined($data{$type}{$name}{circular}{$hod}{quality}) &&
defined($data{$type}{$name}{circular}{$hod}{quality}{$range})) {
$quality = $data{$type}{$name}{circular}{$hod}{quality}{$range};
}
return ($pvcorrf, $quality);
}
################################################################
# Wert des nexthours-Hash zurückliefern
# Usage:
# NexthoursVal ($hash, $hod, $key, $def)
#
# $hod: nächste Stunde (NextHour00, NextHour01,...)
# $key: starttime - Startzeit der abgefragten nächsten Stunde
# pvforecast - PV Vorhersage
# weatherid - DWD Wetter id
# cloudcover - DWD Wolkendichte
# cloudrange - berechnete Bewölkungsrange
# rainprob - DWD Regenwahrscheinlichkeit
# Rad1h - Globalstrahlung (kJ/m2)
# confc - Vorhersage Hausverbrauch (Wh)
# today - 1 wenn heute
# $def: Defaultwert
#
################################################################
sub NexthoursVal {
my $hash = shift;
my $hod = shift;
my $key = shift;
my $def = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
if(defined($data{$type}{$name}{nexthours}) &&
defined($data{$type}{$name}{nexthours}{$hod}) &&
defined($data{$type}{$name}{nexthours}{$hod}{$key})) {
return $data{$type}{$name}{nexthours}{$hod}{$key};
}
return $def;
}
#############################################################################
# Wert des current-Hash zurückliefern
# Usage:
# CurrentVal ($hash, $key, $def)
#
# $key: generation - aktuelle PV Erzeugung
# genslidereg - Schieberegister PV Erzeugung (Array)
# h4fcslidereg - Schieberegister 4h PV Forecast (Array)
# consumerdevs - alle registrierten Consumerdevices (Array)
# gridconsumption - aktueller Netzbezug
# powerbatin - Batterie Ladeleistung
# powerbatout - Batterie Entladeleistung
# temp - aktuelle Außentemperatur
# tomorrowconsumption - Verbrauch des kommenden Tages
# $def: Defaultwert
#
#############################################################################
sub CurrentVal {
my $hash = shift;
my $key = shift;
my $def = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
if(defined($data{$type}{$name}{current}) &&
defined($data{$type}{$name}{current}{$key})) {
return $data{$type}{$name}{current}{$key};
}
return $def;
}
#######################################################################
# Wert des consumer-Hash zurückliefern
# Usage:
# ConsumerVal ($hash, $co, $key, $def)
#
# $co: Consumer Nummer (01,02,03,...)
# $key: name - Name des Verbrauchers (Device)
# alias - Alias des Verbrauchers (Device)
# type - Typ des Verbrauchers
# power - nominale Leistungsaufnahme des Verbrauchers in W
# mode - Planungsmode des Verbrauchers
# icon - Icon für den Verbraucher
# mintime - min. Einschalt- bzw. Zykluszeit
# oncom - Setter Einschaltkommando
# offcom - Setter Ausschaltkommando
# retotal - Reading der Leistungsmessung
# uetotal - Unit der Leistungsmessung
# avgenergy - gemessener Durchschnittsverbrauch eines Tages
# epieces - prognostizierte Energiescheiben (Hash)
# isConsumptionRecommended - ist Verbrauch empfohlen ?
#
# $def: Defaultwert
#
######################################################################
sub ConsumerVal {
my $hash = shift;
my $co = shift;
my $key = shift;
my $def = shift;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
if(defined($data{$type}{$name}{consumers}) &&
defined($data{$type}{$name}{consumers}{$co}{$key}) &&
defined($data{$type}{$name}{consumers}{$co}{$key})) {
return $data{$type}{$name}{consumers}{$co}{$key};
}
return $def;
}
1;
=pod
=item summary Visualization of solar predictions for PV systems and Consumer control
=item summary_DE Visualisierung von solaren Vorhersagen für PV Anlagen und Verbrauchersteuerung
=begin html
SolarForecast
=end html
=begin html_DE
SolarForecast
Das Modul SolarForecast erstellt auf Grundlage der Werte aus generischen Quellendevices eine
Vorhersage für den solaren Ertrag und integriert weitere Informationen als Grundlage für darauf aufbauende Steuerungen.
Die Solargrafik kann ebenfalls in FHEM Tablet UI mit dem
"SolarForecast Widget" integriert werden.
Die solare Vorhersage basiert auf der durch den Deutschen Wetterdienst (DWD) prognostizierten Globalstrahlung am
Anlagenstandort. Im zugeordneten DWD_OpenData Device ist die passende Wetterstation mit dem Attribut "forecastStation"
festzulegen um eine Prognose für diesen Standort zu erhalten.
Abhängig von den DWD-Daten und der physikalischen Anlagengestaltung (Ausrichtung, Winkel, Aufteilung in mehrere Strings, u.a.)
wird auf Grundlage der prognostizierten Globalstrahlung eine wahrscheinliche PV Erzeugung der kommenden Stunden ermittelt.
Darüber hinaus werden Verbrauchswerte bzw. Netzbezugswerte erfasst und für eine Verbrauchsprognose verwendet.
Das Modul errechnet aus den Prognosewerten einen zukünftigen Energieüberschuß der zur Betriebsplanung von Verbrauchern
genutzt wird. Der Nutzer kann Verbraucher (z.B. Schaltsteckdosen) direkt im Modul registrieren und die Planung der
Ein/Ausschaltzeiten sowie deren Ausführung vom SolarForecast Modul übernehmen lassen.
Define
Ein SolarForecast Device wird erstellt mit:
define <name> SolarForecast
Nach der Definition des Devices sind zwingend Vorhersage-Devices des Typs DWD_OpenData zuzuordnen sowie weitere
anlagenspezifische Angaben mit den entsprechenden set-Kommandos zu hinterlegen.
Mit nachfolgenden set-Kommandos werden die Quellendevices und Quellenreadings für maßgebliche Informationen
hinterlegt:
currentForecastDev
DWD_OpenData Device welches Wetterdaten liefert
currentRadiationDev
DWD_OpenData Device welches Strahlungsdaten liefert
currentInverterDev
Device welches PV Leistungsdaten liefert
currentMeterDev
Device welches Netz I/O-Daten liefert
currentBatteryDev
Device welches Batterie Leistungsdaten liefert
Um eine Anpassung an die persönliche Anlage zu ermöglichen, können Korrekturfaktoren manuell
(set <name> pvCorrectionFactor_XX) bzw. automatisiert (set <name> pvCorrectionFactor_Auto on) bestimmt
werden.
Es wird empfohlen die automatische Vorhersagekorrektur unmittelbar einzuschalten, da das SolarForecast Device etliche Tage
benötigt um eine Optimierung der Korrekturfaktoren zu erreichen.
Legt ein beliebiges Device und seine Readings zur Lieferung der Batterie Leistungsdaten fest.
Das Modul geht davon aus dass der numerische Wert der Readings immer positiv ist.
Es kann auch ein Dummy Device mit entsprechenden Readings sein. Die Bedeutung des jeweiligen "Readingname" ist:
pin
Reading welches die aktuelle Batterieladung liefert
pout
Reading welches die aktuelle Batterieentladung liefert
intotal
Reading welches die totale Batterieladung liefert (fortlaufender Zähler)
outtotal
Reading welches die totale Batterieentladung liefert (fortlaufender Zähler)
charge
Reading welches den aktuellen Ladezustand (in Prozent) liefert
Einheit
die jeweilige Einheit (W,Wh,kW,kWh)
Sonderfälle: Sollte das Reading für pin und pout identisch, aber vorzeichenbehaftet sein,
können die Schlüssel pin und pout wie folgt definiert werden:
pin=-pout (ein negativer Wert von pout wird als pin verwendet)
pout=-pin (ein negativer Wert von pin wird als pout verwendet)
Die Einheit entfällt in dem jeweiligen Sonderfall.
Beispiel:
set <name> currentBatteryDev BatDummy pin=BatVal:W pout=-pin intotal=BatInTot:Wh outtotal=BatOutTot:Wh
# Device BatDummy liefert die aktuelle Batterieladung im Reading "BatVal" (W), die Batterieentladung im gleichen Reading mit negativen Vorzeichen,
# die summarische Ladung im Reading "intotal" (Wh), sowie die summarische Entladung im Reading "outtotal" (Wh)
currentForecastDev
Legt das Device (Typ DWD_OpenData) fest, welches die Wetterdaten (Bewölkung, Niederschlag, usw.) liefert.
Ist noch kein Device dieses Typs vorhanden, muß es manuell definiert werden
(siehe DWD_OpenData Commandref).
Im ausgewählten DWD_OpenData Device müssen mindestens diese Attribute gesetzt sein:
Legt ein beliebiges Device und dessen Readings zur Lieferung der aktuellen PV Erzeugungswerte fest.
Es kann auch ein Dummy Device mit entsprechenden Readings sein.
Die Werte mehrerer Inverterdevices führt man z.B. in einem Dummy Device zusammen und gibt dieses Device mit den
entsprechenden Readings an. Die Bedeutung des jeweiligen "Readingname" ist:
pv
Reading welches die aktuelle PV-Erzeugung liefert
etotal
Reading welches die gesamte erzeugten Energie liefert (ein stetig aufsteigender Zähler)
Einheit
die jeweilige Einheit (W,kW,Wh,kWh)
Beispiel:
set <name> currentInverterDev STP5000 pv=total_pac:kW etotal=etotal:kWh
# Device STP5000 liefert PV-Werte. Die aktuell erzeugte Leistung im Reading "total_pac" (kW) und die tägliche Erzeugung im
Reading "etotal" (kWh)
Legt ein beliebiges Device und seine Readings zur Energiemessung fest.
Das Modul geht davon aus dass der numerische Wert der Readings immer positiv ist.
Es kann auch ein Dummy Device mit entsprechenden Readings sein. Die Bedeutung des jeweiligen "Readingname" ist:
gcon
Reading welches die aktuell aus dem Netz bezogene Leistung liefert
contotal
Reading welches die Summe der aus dem Netz bezogenen Energie liefert
gfeedin
Reading welches die aktuell in das Netz eingespeiste Leistung liefert
feedtotal
Reading welches die Summe der in das Netz eingespeisten Energie liefert
Einheit
die jeweilige Einheit (W,kW,Wh,kWh)
Sonderfälle: Sollte das Reading für gcon und gfeedin identisch, aber vorzeichenbehaftet sein,
können die Schlüssel gfeedin und gcon wie folgt definiert werden:
gfeedin=-gcon (ein negativer Wert von gcon wird als gfeedin verwendet)
gcon=-gfeedin (ein negativer Wert von gfeedin wird als gcon verwendet)
Die Einheit entfällt in dem jeweiligen Sonderfall.
Beispiel:
set <name> currentMeterDev Meter gcon=Wirkleistung:W contotal=BezWirkZaehler:kWh gfeedin=-gcon feedtotal=EinWirkZaehler:kWh
# Device Meter liefert den aktuellen Netzbezug im Reading "Wirkleistung" (W),
die Summe des Netzbezugs im Reading "BezWirkZaehler" (kWh), die aktuelle Einspeisung in "Wirkleistung" wenn "Wirkleistung" negativ ist,
die Summe der Einspeisung im Reading "EinWirkZaehler" (kWh)
currentRadiationDev
Legt das Device (Typ DWD_OpenData) fest, welches die solaren Strahlungsdaten liefert. Ist noch kein Device dieses Typs
vorhanden, muß es manuell definiert werden (siehe DWD_OpenData Commandref).
Im ausgewählten DWD_OpenData Device müssen mindestens diese Attribute gesetzt sein:
forecastDays
1
forecastProperties
Rad1h
forecastResolution
1
forecastStation
<Stationscode der ausgewerteten DWD Station>
Hinweis: Die ausgewählte forecastStation muß Strahlungswerte (Rad1h Readings) liefern.
Generiert Trigger bei Über- bzw. Unterschreitung der 4-Stunden PV Vorhersage (NextHours_Sum04_PVforecast).
Überschreiten die letzten drei Messungen der 4-Stunden PV Vorhersagen eine definierte Xon-Bedingung, wird das Reading
energyH4Trigger_X = on erstellt/gesetzt.
Unterschreiten die letzten drei Messungen der 4-Stunden PV Vorhersagen eine definierte Xoff-Bedingung, wird das Reading
energyH4Trigger_X = off erstellt/gesetzt.
Es kann eine beliebige Anzahl von Triggerbedingungen angegeben werden. Xon/Xoff-Bedingungen müssen nicht zwingend paarweise
definiert werden.
Beispiel:
set <name> energyH4Trigger 1on=2000 1off=1700 2on=2500 2off=2000 3off=1500
Ausrichtung <dir> der Solarmodule im String "StringnameX". Der Stringname ist ein Schlüsselwert des
Readings inverterStrings.
Die Richtungsangabe <dir> kann eine der folgenden Werte sein:
N
Nordausrichtung
NE
Nord-Ost Ausrichtung
E
Ostausrichtung
SE
Süd-Ost Ausrichtung
S
Südausrichtung
SW
Süd-West Ausrichtung
W
Westausrichtung
NW
Nord-West Ausrichtung
Beispiel:
set <name> moduleDirection Ostdach=E Südgarage=S S3=NW
Neigungswinkel der Solarmodule. Der Stringname ist ein Schlüsselwert des Readings inverterStrings.
Mögliche Neigungswinkel sind: 0,10,20,30,40,45,50,60,70,80,90 (0 = waagerecht, 90 = senkrecht).
Beispiel:
set <name> moduleTiltAngle Ostdach=40 Südgarage=60 S3=30
plantConfiguration
Je nach ausgewählter Kommandooption werden folgende Operationen ausgeführt:
check
Zeigt die aktuelle Stringkonfiguration. Es wird gleichzeitig eine Plausibilitätsprüfung
vorgenommen und das Ergebnis sowie eventuelle Anweisungen zur Fehlerbehebung ausgegeben.
save
sichert wichtige Parameter der Anlagenkonfiguration
restore
stellt eine gesicherte Anlagenkonfiguration wieder her
Generiert Trigger bei Über- bzw. Unterschreitung bestimmter PV Erzeugungswerte (Current_PV).
Überschreiten die letzten drei Messungen der PV Erzeugung eine definierte Xon-Bedingung, wird das Reading
powerTrigger_X = on erstellt/gesetzt.
Unterschreiten die letzten drei Messungen der PV Erzeugung eine definierte Xoff-Bedingung, wird das Reading
powerTrigger_X = off erstellt/gesetzt.
Es kann eine beliebige Anzahl von Triggerbedingungen angegeben werden. Xon/Xoff-Bedingungen müssen nicht zwingend paarweise
definiert werden.
Beispiel:
set <name> powerTrigger 1on=1000 1off=500 2on=2000 2off=1000 3on=1600 4off=1100
pvCorrectionFactor_Auto on | off
Schaltet die automatische Vorhersagekorrektur ein/aus.
Ist die Automatik eingeschaltet, wird für jede Stunde ein Korrekturfaktor der Solarvorhersage berechnet und intern
gespeichert.
Dazu wird die tatsächliche Energieerzeugung mit dem vorhergesagten Wert des aktuellen Tages und Stunde verglichen,
die Korrekturwerte historischer Tage unter Berücksichtigung der Bewölkung einbezogen und daraus ein neuer Korrekturfaktor
abgeleitet. Es werden nur historische Daten mit gleicher Bewölkungsrange einbezogen.
Zukünftig erwartete PV Erzeugungen werden mit den gespeicherten Korrekturfaktoren optimiert.
Bei aktivierter Autokorrektur haben die Attribute cloudFactorDamping und
rainFactorDamping nur noch eine untergeordnete Bedeutung. Die automatische Vorhersagekorrektur ist lernend und benötigt Zeit um die Korrekturwerte zu optimieren.
Nach der Aktivierung sind nicht sofort optimale Vorhersagen zu erwarten !
(default: off)
pvCorrectionFactor_XX <Zahl>
Manueller Korrekturfaktor für die Stunde XX des Tages zur Anpassung der Vorhersage an die individuelle Anlage.
(default: 1.0)
reset
Löscht die aus der Drop-Down Liste gewählte Datenquelle, zu der Funktion gehörende Readings oder weitere interne
Datenstrukturen.
consumerPlanning
löscht die Planungsdaten aller registrierten Verbraucher
Um die Planungsdaten nur eines Verbrauchers zu löschen verwendet man:
set <name> reset consumerPlanning <Verbrauchernummer>
currentBatteryDev
löscht das eingestellte Batteriedevice und korrespondierende Daten
currentForecastDev
löscht das eingestellte Device für Wetterdaten
currentInverterDev
löscht das eingestellte Inverterdevice und korrespondierende Daten
currentMeterDev
löscht das eingestellte Meterdevice und korrespondierende Daten
energyH4Trigger
löscht die 4-Stunden Energie Triggerpunkte
inverterStrings
löscht die Stringkonfiguration der Anlage
powerTrigger
löscht die Triggerpunkte für PV Erzeugungswerte
pvCorrection
löscht die aktuell ermittelten PV Tageskorrekturfaktoren
Um PV Korrekturfaktoren einer bestimmte Stunde aus pvCircular zu löschen:
set <name> reset pvCorrection circular <Stunde>
(z.B. set <name> reset pvCorrection circular 10)
Um alle bisher gespeicherten PV Korrekturfaktoren aus pvCircular zu löschen:
set <name> reset pvCorrection circular
pvHistory
löscht den Speicher aller historischen Tage (01 ... 31)
Um einen bestimmten historischen Tag zu löschen:
set <name> reset pvHistory <Tag> (z.B. set <name> reset pvHistory 08)
Um eine bestimmte Stunde eines historischer Tages zu löschen:
set <name> reset pvHistory <Tag> <Stunde> (z.B. set <name> reset pvHistory 08 10)
writeHistory
Die vom Device gesammelten historischen PV Daten werden in ein File geschrieben. Dieser Vorgang wird per default
regelmäßig im Hintergrund ausgeführt. Im Internal "HISTFILE" wird der Filename und der Zeitpunkt der letzten
Speicherung dokumentiert.
Get
data
Startet die Datensammlung zur Bestimmung der solaren Vorhersage und anderer Werte.
forecastQualities
Zeigt die aktuell verwendeten Korrekturfaktoren mit der jeweiligen Startzeit zur Bestimmung der PV Vorhersage sowie
deren Qualitäten an.
Die Qualität ergibt sich aus der Anzahl der bereits in der Vergangenheit bewerteten Tage mit einer
identischen Bewölkungsrange.
html
Die Solar Grafik wird als HTML-Code abgerufen und wiedergegeben.
nextHours
Listet die erwarteten Werte der kommenden Stunden auf.
pvfc
erwartete PV Erzeugung
today
=1 wenn Startdatum am aktuellen Tag
confc
erwarteter Energieverbrauch
wid
ID des vorhergesagten Wetters
wcc
vorhergesagter Grad der Bewölkung
crange
berechneter Bewölkungsbereich
correff
effektiv verwendeter Korrekturfaktor/Qualität
Faktor/m - manuell
Faktor/0 - Korrekturfaktor nicht in Store vorhanden (default wird verwendet)
Faktor/1...X - Korrekturfaktor aus Store genutzt (höhere Zahl = bessere Qualität)
wrp
vorhergesagter Grad der Regenwahrscheinlichkeit
Rad1h
vorhergesagte Globalstrahlung
temp
vorhergesagte Außentemperatur
pvHistory
Listet die historischen Werte der letzten Tage (max. 31) sortiert nach dem Tagesdatum und Stunde.
Die Stundenangaben beziehen sich auf die jeweilige Stunde des Tages, z.B. bezieht sich die Stunde 09 auf die Zeit
von 08 - 09 Uhr.
etotal
totaler Energieertrag (Wh) zu Beginn der Stunde
pvfc
der prognostizierte PV Ertrag (Wh)
pvrl
reale PV Erzeugung (Wh)
gcon
realer Leistungsbezug (Wh) aus dem Stromnetz
confc
erwarteter Energieverbrauch (Wh)
con
realer Energieverbrauch (Wh) des Hauses
gfeedin
reale Einspeisung (Wh) in das Stromnetz
batintotal
totale Batterieladung (Wh) zu Beginn der Stunde
batin
Batterieladung der Stunde (Wh)
batouttotal
totale Batterieentladung (Wh) zu Beginn der Stunde
batout
Batterieentladung der Stunde (Wh)
wid
Identifikationsnummer des Wetters
wcc
effektive Wolkenbedeckung
wrp
Wahrscheinlichkeit von Niederschlag > 0,1 mm während der jeweiligen Stunde
pvcorrf
abgeleiteter Autokorrekturfaktor
csmtXX
gemessene Summe Energieverbrauch von ConsumerXX
csmeXX
Energieverbrauch von ConsumerXX in der jeweiligen Stunde bzw. des Tages
hourscsmeXX
gemessene Aktivstunden von ConsumerXX des Tages
pvCircular
Listet die vorhandenen Werte im Ringspeicher auf.
Die Stundenangaben beziehen sich auf die Stunde des Tages, z.B. bezieht sich die Stunde 09 auf die Zeit von 08 - 09 Uhr.
Erläuterung der Werte:
pvfc
PV Vorhersage für die nächsten 24h ab aktueller Stunde des Tages
pvrl
reale PV Erzeugung der letzten 24h (Achtung: pvforecast und pvreal beziehen sich nicht auf den gleichen Zeitraum!)
confc
erwarteter Energieverbrauch (Wh)
gcon
realer Leistungsbezug aus dem Stromnetz
gfeedin
reale Leistungseinspeisung in das Stromnetz
batin
Batterieladung
batout
Batterieentladung
wcc
Grad der Wolkenüberdeckung
wrp
Grad der Regenwahrscheinlichkeit
temp
Außentemperatur
wid
ID des vorhergesagten Wetters
wtxt
Beschreibung des vorhergesagten Wetters
corr
Autokorrekturfaktoren für die Stunde des Tages und der Bewölkungsrange (0..10)
quality
Qualität der Autokorrekturfaktoren (max. 30), höhere Werte = höhere Qualität
valConsumerMaster
Listet die aktuell ermittelten Stammdaten der im Device registrierten Verbraucher auf.
valCurrent
Listet die aktuell ermittelten Werte auf.
Attribute
alias
In Verbindung mit "showLink" ein beliebiger Anzeigename.
autoRefresh
Wenn gesetzt, werden aktive Browserseiten des FHEMWEB-Devices welches das SolarForecast-Device aufgerufen hat, nach der
eingestellten Zeit (Sekunden) neu geladen. Sollen statt dessen Browserseiten eines bestimmten FHEMWEB-Devices neu
geladen werden, kann dieses Device mit dem Attribut "autoRefreshFW" festgelegt werden.
autoRefreshFW
Ist "autoRefresh" aktiviert, kann mit diesem Attribut das FHEMWEB-Device bestimmt werden dessen aktive Browserseiten
regelmäßig neu geladen werden sollen.
beam1Color
Farbauswahl der primären Balken.
beam1Content
Legt den darzustellenden Inhalt der primären Balken fest.
pvForecast
prognostizierte PV-Erzeugung (default)
pvReal
reale PV-Erzeugung
gridconsumption
Energie Bezug aus dem Netz
consumptionForecast
prognostizierter Energieverbrauch
beam2Color
Farbauswahl der sekundären Balken. Die zweite Farbe ist nur sinnvoll für den Anzeigedevice-Typ "pvco" und "diff".
beam2Content
Legt den darzustellenden Inhalt der sekundären Balken fest.
pvForecast
prognostizierte PV-Erzeugung (default)
pvReal
reale PV-Erzeugung
gridconsumption
Energie Bezug aus dem Netz
consumptionForecast
prognostizierter Energieverbrauch
beamHeight <value>
Höhe der Balken in px und damit Bestimmung der gesammten Höhe.
In Verbindung mit "hourCount" lassen sich damit auch recht kleine Grafikausgaben erzeugen.
(default: 200)
beamWidth <value>
Breite der Balken in px.
(default: 6 (auto))
cloudFactorDamping
Prozentuale Berücksichtigung (Dämpfung) des Bewölkungprognosefaktors bei der solaren Vorhersage.
Größere Werte vermindern, kleinere Werte erhöhen tendenziell den prognostizierten PV Ertrag.
(default: 35)
consumerAdviceIcon
Definiert die Art der Information über die geplanten Schaltzeiten eines Verbrauchers in der Verbraucherlegende.
<Icon>@<Farbe>
Aktivierungsempfehlung wird durch Icon und Farbe (optional) dargestellt (default: light_light_dim_100@gold)
(die Planungsdaten werden als Mouse-Over Text angezeigt
times
es werden der Planungsstatus und die geplanten Schaltzeiten als Text angezeigt
none
keine Anzeige der Planungsdaten
consumerLegend
Definiert die Lage bzw. Darstellungsweise der Verbraucherlegende sofern Verbraucher SolarForecast Device
registriert sind.
(default: icon_top)
Registriert einen Verbraucher <Device Name> beim SolarForecast Device. Dabei ist <Device Name>
ein in FHEM bereits angelegtes Verbraucher Device, z.B. eine Schaltsteckdose. Die meisten Schlüssel sind optional,
sind aber für bestimmte Funktionalitäten Voraussetzung und werden mit default-Werten besetzt.
Ist der Schüssel "auto" definiert, kann der Automatikmodus in der integrierten Verbrauchergrafik mit den
entsprechenden Drucktasten umgeschaltet werden. Das angegebene Reading wird ggf. im Consumer Device angelegt falls
es nicht vorhanden ist.
type
Typ des Verbrauchers. Folgende Typen sind erlaubt:
dishwasher - Verbaucher ist eine Spülmschine
dryer - Verbaucher ist ein Wäschetrockner
washingmachine - Verbaucher ist eine Waschmaschine
heater - Verbaucher ist ein Heizstab
other - Verbraucher ist keiner der vorgenannten Typen
power
typische Leistungsaufnahme des Verbrauchers (siehe Datenblatt) in W
mode
Planungsmodus des Verbrauchers (optional). Erlaubt sind:
can - der Verbaucher kann angeschaltet werden wenn genügend Energie bereitsteht (default)
must - der Verbaucher muß einmal am Tag angeschaltet werden auch wenn nicht genügend Energie vorhanden ist
icon
Icon zur Darstellung des Verbrauchers in der Übersichtsgrafik (optional)
mintime
Mindestlaufzeit bzw. typische Laufzeit für einen Zyklus des Verbrauchers nach dem Einschalten in Minuten (default: Typ bezogen)
on
Set-Kommando zum Einschalten des Verbrauchers (optional)
off
Set-Kommando zum Ausschalten des Verbrauchers (optional)
notbefore
Verbraucher nicht vor angegebener Stunde (01..23) einschalten (optional)
notafter
Verbraucher nicht nach angegebener Stunde (01..23) einschalten (optional)
auto
Reading im Verbraucherdevice welches das Schalten des Verbrauchers freigibt bzw. blockiert (optional)
Css
Definiert den Style für die Energieflußgrafik. Das Attribut wird automatisch vorbelegt.
Zum Ändern des Css-Attributes bitte den Default übernehmen und anpassen:
debug
Aktiviert/deaktiviert Debug-Meldungen im Modul.
disable
Aktiviert/deaktiviert das Device.
flowGraphicAnimate
Animiert die Energieflußgrafik sofern angezeigt.
Siehe auch Attribut graphicSelect.
(default: 0)
flowGraphicSize <Pixel>
Größe der Energieflußgrafik sofern angezeigt.
Siehe auch Attribut graphicSelect.
(default: 300)
follow70percentRule
Wenn gesetzt, wird die prognostizierte Leistung entsprechend der 70% Regel begrenzt.
0
keine Begrenzung der prognostizierten PV-Erzeugung (default)
1
die prognostizierte PV-Erzeugung wird auf 70% der installierten Stringleistung(en) begrenzt
dynamic
die prognostizierte PV-Erzeugung wird begrenzt wenn 70% der installierten
Stringleistung(en) zzgl. des prognostizierten Verbrauchs überschritten wird
forcePageRefresh
Das Attribut wird durch das SMAPortal-Device ausgewertet.
Wenn gesetzt, wird ein Reload aller Browserseiten mit aktiven FHEMWEB-Verbindungen nach dem Update des
Eltern-SMAPortal-Devices erzwungen.
graphicSelect
Wählt die anzuzeigende interne Grafik des Moduls aus.
Zur Anpassung der Energieflußgrafik steht das Attribut Css zur
Verfügung.
flow
zeigt die Energieflußgrafik an
forecast
zeigt die Vorhersagegrafik an
both
zeigt Energiefluß- und Vorhersagegrafik an (default)
none
es wird keine Grafik angezeigt
historyHour
Anzahl der vorangegangenen Stunden die in der Balkengrafik dargestellt werden.
(default: 0)
hourCount <4...24>
Anzahl der Balken/Stunden.
(default: 24)
headerDetail
Detailiierungsgrad der Kopfzeilen.
(default: all)
all
Anzeige Erzeugung (PV), Verbrauch (CO), Link zur Device Detailanzeige + Aktualisierungszeit (default)
co
nur Verbrauch (CO)
pv
nur Erzeugung (PV)
pvco
Erzeugung (PV) und Verbrauch (CO)
statusLink
Link zur Device Detailanzeige + Aktualisierungszeit
hourStyle
Format der Zeitangabe.
nicht gesetzt
nur Stundenangabe ohne Minuten (default)
:00
Stunden sowie Minuten zweistellig, z.B. 10:00
:0
Stunden sowie Minuten einstellig, z.B. 8:0
htmlStart <HTML-String>
Angabe eines beliebigen HTML-Strings der vor dem Grafik-Code ausgeführt wird.
htmlEnd <HTML-String>
Angabe eines beliebigen HTML-Strings der nach dem Grafik-Code ausgeführt wird.
interval <Sekunden>
Zeitintervall der Datensammlung.
Ist interval explizit auf "0" gesetzt, erfolgt keine automatische Datensammlung und muss mit "get <name> data"
manuell erfolgen.
(default: 70)
layoutType <single | double | diff>
Layout der integrierten Grafik.
Der darzustellende Inhalt der Balken wird durch die Attribute beam1Content bzw. beam2Content
bestimmt.
(default: single)
single
- zeigt nur den primären Balken an
double
- zeigt den primären Balken und den sekundären Balken an
maxValBeam <0...val>
Festlegung des maximalen Betrags des primären Balkens (Stundenwert) zur Berechnung der maximalen Balkenhöhe.
Dadurch erfolgt eine Anpassung der zulässigen Gesamthöhe der Grafik.
Wenn nicht gesetzt oder 0, erfolgt eine dynamische Anpassung.
(default: 0)
maxVariancePerDay <Zahl>
Maximale Änderungsgröße des PV Vorhersagefaktors (Reading pvCorrectionFactor_XX) pro Tag.
(default: 0.5)
numHistDays
Anzahl der historischen Tage aus Cache 'pvHistory' die zur Autokorrektur der PV Vorhersage verwendet werden.
(default: alle verfügbaren Daten in pvHistory und pvCircular)
preferredChargeBattery
Es werden Verbraucher mit dem Mode can erst dann eingeschaltet, wenn die angegebene Batterieladung (%)
erreicht ist.
Verbraucher mit dem Mode must beachten die Vorrangladung der Batterie nicht.
(default: 0)
rainFactorDamping
Prozentuale Berücksichtigung (Dämpfung) des Regenprognosefaktors bei der solaren Vorhersage.
Größere Werte vermindern, kleinere Werte erhöhen tendenziell den prognostizierten PV Ertrag.
(default: 10)
sameWeekdaysForConsfc
Wenn gesetzt, werden zur Berechnung der Verbrauchsprognose nur gleiche Wochentage (Mo..So) einbezogen.
Anderenfalls werden alle Wochentage gleichberechtigt zur Kalkulation verwendet.
(default: 0)
showDiff <no | top | bottom>
Zusätzliche Anzeige der Differenz "Ertrag - Verbrauch" wie beim Anzeigetyp Differential (diff).
(default: no)
showHeader
Anzeige der Kopfzeile mit Prognosedaten, Rest des aktuellen Tages und des nächsten Tages
(default: 1)
showLink
Anzeige des Detail-Links über dem Grafik-Device
(default: 1)
showNight
Die Nachtstunden (ohne Ertragsprognose) werden mit angezeigt.
(default: 0)
showWeather
Wettericons anzeigen.
(default: 1)
spaceSize <value>
Legt fest wieviel Platz in px über oder unter den Balken (bei Anzeigetyp Differential (diff)) zur Anzeige der
Werte freigehalten wird. Bei Styles mit große Fonts kann der default-Wert zu klein sein bzw. rutscht ein
Balken u.U. über die Grundlinie. In diesen Fällen bitte den Wert erhöhen.
(default: 24)
Wh/kWh <Wh | kWh>
Definiert die Anzeigeeinheit in Wh oder in kWh auf eine Nachkommastelle gerundet.
(default: W)
weatherColor
Farbe der Wetter-Icons.
weatherColorNight
Farbe der Wetter-Icons für die Nachtstunden.