";
$ret .= "\n"; # das \n erleichtert das Lesen der debug Quelltextausgabe
if ($header) { # Header ausgeben
$ret .= "";
# mit einem extra | ein wenig mehr Platz machen, ergibt i.d.R. weniger als ein Zeichen
$ret .= "$header | ";
}
if ($legend_txt && ($legend eq 'top')) {
$ret .= "";
$ret .= "| $legend_txt | ";
}
if ($weather) {
$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});
Log3($name, 4, "$name - unknown weather id: ".$hfcg->{$i}{weather}.", please inform the maintainer") if($icon_name eq 'unknown');
$icon_name .= ($hfcg->{$i}{weather} < 100 ) ? '@'.$colorw : '@'.$colorwn;
$val = FW_makeImage($icon_name);
if ($val eq $icon_name) { # passendes Icon beim User nicht vorhanden ! ( attr web iconPath falsch/prüfen/update ? )
$val ='???';
Log3($name, 3, qq{$name - the icon $hfcg->{$i}{weather} not found. Please check attribute "iconPath" of your FHEMWEB instance and/or update your FHEM software});
}
$ret .= "$val | "; # title -> Mouse Over Text
# mit $hfcg->{$i}{weather} = undef kann man unten leicht feststellen ob für diese Spalte bereits ein Icon ausgegeben wurde oder nicht
}
else {
$ret .= " | ";
$hfcg->{$i}{weather} = undef; # ToDo : prüfen ob noch nötig
}
}
$ret .= " | "; # freier Platz am Ende der Icon Zeile
}
if($show_diff eq 'top') { # Zusätzliche Zeile Ertrag - Verbrauch
$ret .= " | "; # freier Platz am Anfang
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') { # Typ 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 .="\n";
if ($lotype eq 'single') {
$val = formatVal6($hfcg->{$i}{beam1},$kw,$hfcg->{$i}{weather});
$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,@pgCDev) 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,@pgCDev) 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 .= "";
$ret .= "| ".$val." | ";
}
if ($hfcg->{$i}{diff} >= 0) { # mit Farbe 1 colorfc füllen
$style .= " background-color:#$colorfc'";
$z2 = 1 if ($hfcg->{$i}{diff} == 0); # Sonderfall , 1px dünnen Strich ausgeben
$ret .= "";
$ret .= "| ";
$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 .= " | ";
}
}
if ($hfcg->{$i}{diff} < 0) { # Negativ Balken anzeigen ?
$style .= " background-color:#$colorc'"; # mit Farbe 2 colorc füllen
$ret .= "";
$ret .= " | ";
}
elsif ($z3) { # ohne Farbe
$ret .= "";
$ret .= " | ";
}
if($z4) { # kann entfallen wenn auch z3 0 ist
$val = ($hfcg->{$i}{diff} < 0) ? formatVal6($hfcg->{$i}{diff},$kw,$hfcg->{$i}{weather}) : ' ';
$ret .= "";
$ret .= "| ".$val." | ";
}
}
if ($show_diff eq 'bottom') { # zusätzliche diff Anzeige
$val = formatVal6($hfcg->{$i}{diff},$kw,$hfcg->{$i}{weather});
$val = ($hfcg->{$i}{diff} < 0) ? ''.$val.'' : ($val > 0 ) ? '+'.$val : $val if ($val ne ' '); # negative Zahlen in Fettschrift, 0 aber ohne +
$ret .= "| $val | ";
}
$ret .= "| ";
$ret .= (($hfcg->{$i}{time} == $thishour) && ($offset < 0)) ? ''.$hfcg->{$i}{time_str}.'' : $hfcg->{$i}{time_str};
$thishour = 99 if ($hfcg->{$i}{time} == $thishour); # nur einmal verwenden !
$ret .=" | ";
}
$ret .= " | ";
###################
# Legende unten
if ($legend_txt && ($legend eq 'bottom')) {
$ret .= "";
$ret .= "| ";
$ret .= "$legend_txt | ";
}
$ret .= " ";
$ret .= $html_end if (defined($html_end));
$ret .= "";
return $ret;
}
################################################################
# Inject consumer icon
################################################################
sub consinject {
my ($hash,$i,@pgCDev) = @_;
my $name = $hash->{NAME};
my $ret = "";
for (@pgCDev) {
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','';
}
################################################################
# Timestamp berechnen
################################################################
sub TimeAdjust {
my $epoch = shift;
my ($lyear,$lmonth,$lday,$lhour) = (localtime($epoch))[5,4,3,2];
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);
if(AttrVal("global","language","EN") eq "DE") {
$ts = sprintf("%02d.%02d.%04d %02d:%s", $lday,$lmonth,$lyear,$lhour,"00:00");
}
else {
$ts = sprintf("%04d-%02d-%02d %02d:%s", $lyear,$lmonth,$lday,$lhour,"00:00");
}
return ($ts,$realts);
}
################################################################
# benötigte Attribute im DWD Device checken
################################################################
sub checkdwdattr {
my $dwddev = shift;
my @fcprop = map { trim($_) } split ",", AttrVal($dwddev, "forecastProperties", "pattern");
my @aneeded;
for my $am (@dwdattrmust) {
next if($am ~~ @fcprop);
push @aneeded, $am;
}
return @aneeded;
}
##################################################################################################
# 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 $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 $chour = strftime "%H", localtime($t+($num*3600)); # aktuelle Stunde
my $reld = $fd == 0 ? "today" : $fd == 1 ? "tomorrow" : "unknown";
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 $cloudcover = NexthoursVal ($hash, "NextHour".sprintf("%02d",$num), "cloudcover", 0); # effektive Wolkendecke
my $ccf = 1 - ((($cloudcover - $cloud_base)/100) * $clouddamp/100); # Cloud Correction Faktor mit Steilheit und Fußpunkt
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 $kw = AttrVal ($name, 'Wh/kWh', 'Wh');
my $hc = ReadingsNum ($name, "pvCorrectionFactor_".sprintf("%02d",$fh+1), 1); # Korrekturfaktor der Stunde des Tages einbeziehen
my $pvsum = 0;
for my $st (@strings) { # für jeden String der Config ..
my $peak = $stch->{"$st"}{peak}; # String Peak (kWp)
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
$hc = 1 if(1*$hc == 0);
my $pv = sprintf "%.1f", ($rad * $af * $kJtokWh * $peak * $pr * $hc * $ccf * $rcf * 1000);
my $lh = { # Log-Hash zur Ausgabe
"moduleDirection" => $moddir,
"modulePeakString" => $peak,
"moduleTiltAngle" => $ta,
"Area factor" => $af,
"Cloudcover" => $cloudcover,
"CloudFactorDamping" => $clouddamp." %",
"Cloudfactor" => $ccf,
"Rainprob" => $rainprob,
"Rainfactor" => $rcf,
"RainFactorDamping" => $raindamp." %",
"pvCorrectionFactor" => $hc,
"Radiation" => $rad,
"Factor kJ to kWh" => $kJtokWh,
"PV generation" => $pv." Wh"
};
my $sq;
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)." string: $st ->\n$sq");
$pvsum += $pv;
}
if($kw eq "Wh") {
$pvsum = int $pvsum;
}
Log3($name, 4, "$name - PV forecast calc for $reld Hour ".sprintf("%02d",$chour+1)." summary: $pvsum");
return $pvsum;
}
################################################################
# Abweichung PVreal / PVforecast berechnen
# bei eingeschalteter automat. Korrektur
################################################################
sub calcVariance {
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $chour = $paref->{chour};
my $dcauto = ReadingsVal ($name, "pvCorrectionFactor_Auto", "off"); # nur bei "on" automatische Varianzkalkulation
if($dcauto =~ /^off/x) {
Log3($name, 4, "$name - automatic Variance calculation is switched off.");
return;
}
my $tlim = "00"; # Stunde 00 -> löschen aller Autocalc Statusreadings des Tages
if($chour =~ /^($tlim)$/x) {
deleteReadingspec ($hash, "pvCorrectionFactor_.*_autocalc");
}
my $idts = ReadingsTimestamp($name, "currentInverterDev", ""); # Definitionstimestamp des Inverterdevice
return if(!$idts);
$idts = timestringToTimestamp ($hash, $idts);
my $t = time; # aktuelle Unix-Zeit
if($t - $idts < 86400) {
my $rmh = sprintf "%.1f", ((86400 - ($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;
}
my $oldfac = ReadingsNum ($name, "pvCorrectionFactor_".sprintf("%02d",$h), 1); # bisher definierter Korrekturfaktor
$oldfac = 1 if(1*$oldfac == 0);
Log3($name, 5, "$name - Hour: ".sprintf("%02d",$h).", Today PVreal: $pvval, PVforecast: $fcval");
$paref->{hour} = $h;
my ($pvavg,$fcavg) = calcFromHistory ($paref); # historische PV / Forecast Vergleichswerte ermitteln
$pvval = $pvavg ? ($pvval + $pvavg) / 2 : $pvval; # Ertrag aktuelle Stunde berücksichtigen
$fcval = $fcavg ? ($fcval + $fcavg) / 2 : $fcval; # Vorhersage aktuelle Stunde berücksichtigen
Log3 ($name, 4, "$name - PV History -> average hour ($h) -> real: $pvval, forecast: $fcval");
my $factor = sprintf "%.2f", ($pvval / $fcval); # Faktorberechnung: reale PV / Prognose
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);
}
push @da, "pvCorrectionFactor_".sprintf("%02d",$h)."<>".$factor." (automatic - old factor: $oldfac)";
push @da, "pvCorrectionFactor_".sprintf("%02d",$h)."_autocalc<>done";
}
createReadingsFromArray ($hash, \@da, 1);
return;
}
################################################################
# Berechne Durchschnitte aus Werten der PV History
################################################################
sub calcFromHistory {
my $paref = shift;
my $hash = $paref->{hash};
my $t = $paref->{t}; # aktuelle Unix-Zeit
my $hour = $paref->{hour}; # Stunde für die der Durchschnitt bestimmt werden soll
$hour = sprintf("%02d",$hour);
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my $day = strftime "%d", localtime($t); # aktueller Tag
my $pvhh = $data{$type}{$name}{pvhist};
my $calcd = AttrVal($name, "numHistDays", $calcmaxd);
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..$calcd) {
last if($e == $calcd || $k[$ei] == $day);
unshift @efa, $k[$ei];
$ei--;
}
my $anzavg = scalar(@efa);
if($anzavg) {
Log3 ($name, 4, "$name - PV History -> Day $day has index $idx. Days ($calcd) for calc: ".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;
}
my ($pvrl,$pvfc) = (0,0);
for my $dayfa (@efa) {
$pvrl += HistoryVal ($hash, $dayfa, $hour, "pvrl", 0);
$pvfc += HistoryVal ($hash, $dayfa, $hour, "pvfc", 0);
}
my $pvavg = sprintf "%.2f", $pvrl / $anzavg;
my $fcavg = sprintf "%.2f", $pvfc / $anzavg;
return ($pvavg,$fcavg);
}
return;
}
################################################################
# 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 $histname = $paref->{histname} // qq{};
my $ethishour = $paref->{ethishour} // 0;
my $calcpv = $paref->{calcpv} // 0;
my $gcthishour = $paref->{gctotthishour} // 0; # Grid Consumption
my $fithishour = $paref->{gftotthishour} // 0; # Grid Feed In
my $wid = $paref->{wid} // -1;
my $type = $hash->{TYPE};
my $val = q{};
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 "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 "weatherid") { # Wetter ID
$val = $wid;
$data{$type}{$name}{pvhist}{$day}{$nhour}{weatherid} = $wid;
$data{$type}{$name}{pvhist}{$day}{99}{weatherid} = q{};
}
Log3 ($name, 5, "$name - set PV History 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", 0);
my $pvfc = HistoryVal ($hash, $day, $key, "pvfc", 0);
my $gcons = HistoryVal ($hash, $day, $key, "gcons", 0);
my $gfeedin = HistoryVal ($hash, $day, $key, "gfeedin", 0);
my $wid = HistoryVal ($hash, $day, $key, "weatherid", -1);
$ret .= "\n " if($ret);
$ret .= $key." => pvreal: $pvrl, pvforecast: $pvfc, gridcon: $gcons, gfeedin: $gfeedin, weatherid: $wid";
}
return $ret;
};
if ($htol eq "pvhist") {
$h = $data{$type}{$name}{pvhist};
if (!keys %{$h}) {
return qq{PV cache is empty.};
}
for my $idx (reverse sort{$a<=>$b} keys %{$h}) {
$sq .= $idx." => ".$sub->($idx)."\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", 0);
my $pvrl = CircularVal ($hash, $idx, "pvrl", 0);
my $gcons = CircularVal ($hash, $idx, "gcons", 0);
my $gfeedin = CircularVal ($hash, $idx, "gfeedin", 0);
my $wid = CircularVal ($hash, $idx, "weatherid", -1);
my $wtxt = CircularVal ($hash, $idx, "weathertxt", "");
my $wccv = CircularVal ($hash, $idx, "weathercloudcover", 0);
my $wrprb = CircularVal ($hash, $idx, "weatherrainprob", 0);
$sq .= "\n" if($sq);
$sq .= $idx." => pvforecast: $pvfc, pvreal: $pvrl, gcons: $gcons, gfeedin: $gfeedin, weathercloudcover: $wccv, weatherrainprob: $wrprb, weatherid: $wid, weathertxt: $wtxt";
}
}
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", qq{});
my $nhfc = NexthoursVal ($hash, $idx, "pvforecast", 0);
my $wid = NexthoursVal ($hash, $idx, "weatherid", -1);
my $neff = NexthoursVal ($hash, $idx, "cloudcover", 0);
my $r101 = NexthoursVal ($hash, $idx, "rainprob", 0);
my $rad1h = NexthoursVal ($hash, $idx, "Rad1h", 0);
$sq .= "\n" if($sq);
$sq .= $idx." => starttime: $nhts, pvforecast: $nhfc, weatherid: $wid, cloudcover: $neff, rainprob: $r101, Rad1h: $rad1h";
}
}
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 $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)."\n";
$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 .= "\n\nOh no 🙁, your string configuration is inconsistent.\nPlease check the settings of modulePeakString, moduleDirection, moduleTiltAngle !";
}
else {
$sc .= "\n\nCongratulations 😊, your string configuration checked without found errors !";
}
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;
}
################################################################
# einen Zeitstring YYYY-MM-TT hh:mm:ss in einen Unix
# Timestamp umwandeln
################################################################
sub timestringToTimestamp {
my $hash = shift;
my $tstring = shift;
my $name = $hash->{NAME};
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};
RemoveInternalTimer($hash, "FHEM::SolarForecast::createNotifyDev");
if($init_done == 1) {
my @nd;
my ($afc,$ain,$ame,$h);
my $fcdev = ReadingsVal($name, "currentForecastDev", ""); # Forecast Device
($afc,$h) = parseParams ($fcdev);
$fcdev = $afc->[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] // "";
push @nd, $fcdev;
push @nd, $indev;
push @nd, $medev;
if(@nd) {
$hash->{NOTIFYDEV} = join ",", @nd;
readingsSingleUpdate ($hash, ".associatedWith", join(" ",@nd), 0);
}
}
else {
InternalTimer(gettimeofday()+3, "FHEM::SolarForecast::createNotifyDev", $hash, 0);
}
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: pvrl - realer PV Ertrag
# pvfc - PV Vorhersage
# gcons - realer Netzbezug
# gfeedin - reale Netzeinspeisung
# $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
# Usage:
# CircularVal ($hash, $hod, $key, $def)
#
# $hod: Stunde des Tages (01,02,...,24)
# $key: pvrl - realer PV Ertrag
# pvfc - PV Vorhersage
# gcons - realer Netzbezug
# gfeedin - reale Netzeinspeisung
# weatherid - DWD Wetter id
# weathertxt - DWD Wetter Text
# weathercloudcover - DWD Wolkendichte
# weatherrainprob - DWD Regenwahrscheinlichkeit
# $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 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
# rainprob - DWD Regenwahrscheinlichkeit
# Rad1h - Globalstrahlung (kJ/m2)
# $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)
# gridconsumption - aktueller Netzbezug
# $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;
}
1;
=pod
=item summary Visualization of solar predictions for PV systems
=item summary_DE Visualisierung von solaren Vorhersagen für PV Anlagen
=begin html
=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 weitere Informationen als Grundlage für abhängige 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 der physikalischen Anlagengestaltung (Ausrichtung, Winkel, Aufteilung in mehrere Strings, u.a.) wird die
verfügbare Globalstrahlung ganz spezifisch in elektrische Energie umgewandelt.
Define
Ein SolarForecast Device wird einfach erstellt mit:
define <name> SolarForecast
Nach der Definition des Devices ist zwingend ein Vorhersage-Device des Typs DWD_OpenData zuzuordnen sowie weitere
anlagenspezifische Angaben mit dem entsprechenden set-Kommando vorzunehmen.
Mit nachfolgenden set-Kommandos werden die Quellendevices und Quellenreadings für maßgebliche Informationen
hinterlegt:
| currentForecastDev | Device welches Wetter- und Strahlungsdaten liefert |
| currentInverterDev | Device welches PV Leistungsdaten liefert |
| currentMeterDev | Device welches Netz I/O-Daten 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) eingefügt
werden.
Set
- currentForecastDev
Legt das Device (Typ DWD_OpenData) fest, welches die Daten der solaren Vorhersage 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,TTT,Neff,R101,ww,SunUp,SunRise,SunSet |
| forecastResolution | 1 |
| forecastStation | <Stationscode der ausgewerteten DWD Station> |
| | Hinweis: Die ausgewählte forecastStation muß Strahlungswerte (Rad1h Readings) liefern. |
- currentInverterDev <Inverter Device Name> pv=<Readingname>:<Einheit> etotal=<Readingname>:<Einheit>
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)
- currentMeterDev <Meter Device Name> gcon=<Readingname>:<Einheit> contotal=<Readingname>:<Einheit> gfeedin=<Readingname>:<Einheit> feedtotal=<Readingname>:<Einheit>
Legt ein beliebiges Device und seine Readings zur Energiemessung fest.
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) |
Beispiel:
set <name> currentMeterDev SMA_Energymeter gcon=Bezug_Wirkleistung:W contotal=Bezug_Wirkleistung_Zaehler:kWh gfeedin=Einspeisung_Wirkleistung:W feedtotal=Einspeisung_Wirkleistung_Zaehler:kWh
# Device SMA_Energymeter liefert den aktuellen Netzbezug im Reading "Bezug_Wirkleistung" (W),
die Summe des Netzbezugs im Reading "Bezug_Wirkleistung_Zaehler" (kWh), die aktuelle Einspeisung im Reading "Bezug_Wirkleistung_Zaehler" (W),
die Summe der Einspeisung im Reading "Einspeisung_Wirkleistung_Zaehler" (kWh)
- energyH4Trigger <1on>=<Wert> <1off>=<Wert> [<2on>=<Wert> <2off>=<Wert> ...]
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
- inverterStrings <Stringname1>[,<Stringname2>,<Stringname3>,...]
Bezeichnungen der am Wechselrichter aktiven Strings. Diese Bezeichnungen werden als Schlüssel in den weiteren
Settings verwendet.
Beispiel:
set <name> inverterStrings Ostdach,Südgarage,S3
- modulePeakString <Stringname1>=<Peak> [<Stringname2>=<Peak> <Stringname3>=<Peak> ...]
Die Peakleistung des Strings "StringnameX" in kWp. Der Stringname ist ein Schlüsselwert des
Readings inverterStrings.
Beispiel:
set <name> modulePeakString Ostdach=5.1 Südgarage=2.0 S3=7.2
- moduleDirection <Stringname1>=<dir> [<Stringname2>=<dir> <Stringname3>=<dir> ...]
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
- moduleTiltAngle <Stringname1>=<Winkel> [<Stringname2>=<Winkel> <Stringname3>=<Winkel> ...]
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
- powerTrigger <1on>=<Wert> <1off>=<Wert> [<2on>=<Wert> <2off>=<Wert> ...]
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 nach einer Mindestlaufzeit von FHEM bzw. des Moduls von 24 Stunden für jede Stunde
ein Korrekturfaktor der Solarvorhersage berechnet und auf die Erwartung des kommenden Tages angewendet.
Dazu wird die tatsächliche Energierzeugung mit dem vorhergesagten Wert des aktuellen Tages und Stunde vergleichen und
daraus eine Korrektur abgeleitet.
(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 bzw. zu der Funktion gehörende Readings.
- 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
- html
Die Solar Grafik wird als HTML-Code abgerufen und wiedergegeben.
- data
Startet die Datensammlung zur Bestimmung der solaren Vorhersage und anderer Werte.
- nextHours
Listet die erwarteten Werte der nächsten Stunden auf.
- 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.
| pvforecast | der prognostizierte PV Ertrag der jeweiligen Stunde |
| pvreal | reale PV Erzeugung der jeweiligen Stunde |
| gcons | realer Leistungsbezug aus dem Stromnetz der jeweiligen Stunde |
| gfeedin | reale Einspeisung in das Stromnetz der jeweiligen Stunde |
- 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:
| pvforecast | PV Vorhersage für die nächsten 24h ab aktueller Stunde des Tages |
| pvreal | reale PV Erzeugung der letzten 24h (Achtung: pvforecast und pvreal beziehen sich nicht auf den gleichen Zeitraum!) |
| gcons | realer Leistungsbezug aus dem Stromnetz |
| gfeedin | reale Leistungseinspeisung in das Stromnetz |
| weathercloudcover | Grad der Wolkenüberdeckung |
| weatherrainprob | Grad der Regenwahrscheinlichkeit |
| weatherid | ID des vorhergesagten Wetters |
| weathertxt | Beschreibung des vorhergesagten Wetters |
- stringConfig
Zeigt die aktuelle Stringkonfiguration. Dabei wird gleichzeitig eine Plausibilitätsprüfung vorgenommen und das Ergebnis
sowie eventuelle Anweisungen zur Fehlerbehebung ausgegeben.
- 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.
| forecast | Vorhersage der PV-Erzeugung (default) |
| real | tatsächliche PV-Erzeugung |
| gridconsumption | Energie Bezug aus dem Netz |
- 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.
| forecast | Vorhersage der PV-Erzeugung (default) |
| real | tatsächliche PV-Erzeugung |
| gridconsumption | Energie Bezug aus dem Netz |
- 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: 45)
- disable
Aktiviert/deaktiviert das Device.
- 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.
- headerAlignment <center | left | right>
Ausrichtung der Kopfzeilen.
(default: center)
- 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 |
| diff | - Differenzanzeige. Es gilt: <Differenz> = <Wert primärer Balken> - <Wert sekundärer Balken> |
- 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 vergangenen Tage (historische Daten) die zur Autokorrektur der PV Vorhersage verwendet werden sofern
aktiviert.
(default: 7)
- 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: 20)
- 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.
=end html_DE
=for :application/json;q=META.json 76_SolarForecast.pm
{
"abstract": "Visualization of solar predictions for PV systems",
"x_lang": {
"de": {
"abstract": "Visualisierung von solaren Vorhersagen für PV Anlagen"
}
},
"keywords": [
"sma",
"photovoltaik",
"electricity",
"portal",
"smaportal",
"graphics",
"longpoll",
"refresh"
],
"version": "v1.1.1",
"release_status": "testing",
"author": [
"Heiko Maaz "
],
"x_fhem_maintainer": [
"DS_Starter"
],
"x_fhem_maintainer_github": [
"nasseeder1"
],
"prereqs": {
"runtime": {
"requires": {
"FHEM": 5.00918799,
"perl": 5.014,
"Time::HiRes": 0
},
"recommends": {
"FHEM::Meta": 0
},
"suggests": {
}
}
},
"resources": {
"repository": {
"x_dev": {
"type": "svn",
"url": "https://svn.fhem.de/trac/browser/trunk/fhem/contrib/DS_Starter",
"web": "https://svn.fhem.de/trac/browser/trunk/fhem/contrib/DS_Starter/76_SolarForecast.pm",
"x_branch": "dev",
"x_filepath": "fhem/contrib/",
"x_raw": "https://svn.fhem.de/fhem/trunk/fhem/contrib/DS_Starter/76_SolarForecast.pm"
}
}
}
}
=end :application/json;q=META.json
=cut
| |
![](\"$FW_ME/www/images/default/10px-kreis-rot.png\")
![](\"$FW_ME/www/images/default/1px-spacer.png\"){kind=spacer}
";
if($swstate eq "off") {
$swicon = "![](\"$FW_ME/www/images/default/10px-kreis-gruen.png\")
";
}
elsif ($swstate =~ /off.*automatic.*/ix) {
$swicon = "![](\"$FW_ME/www/images/default/10px-kreis-gelb.png\")
";
}
if ($legend_style eq 'icon') { # mögliche Umbruchstellen mit normalen Blanks vorsehen !
$legend_txt .= $txt.' '.FW_makeImage($im).' '.$swicon.' ';
}
else {
my (undef,$co) = split('\@',$im);
$co = '#cccccc' if (!$co); # Farbe per default
$legend_txt .= ''.$txt.' '.$swicon.' '; # hier auch Umbruch erlauben
}
}
}
###################################
# Parameter f. Anzeige extrahieren
###################################
my $maxhours = AttrNum ($name, 'hourCount', 24 );
my $offset = AttrNum ($name, 'historyHour', 0 );
my $hourstyle = AttrVal ($name, 'hourStyle', '' );
my $colorfc = AttrVal ($name, 'beam1Color', '000000');
my $colorc = AttrVal ($name, 'beam2Color', 'C4C4A7');
my $fcolor1 = AttrVal ($name, 'beam1FontColor', 'C4C4A7');
my $fcolor2 = AttrVal ($name, 'beam2FontColor', '000000');
my $beam1cont = AttrVal ($name, 'beam1Content', 'forecast');
my $beam2cont = AttrVal ($name, 'beam2Content', 'forecast');
my $icon = AttrVal ($name, 'consumerAdviceIcon', undef );
my $html_start = AttrVal ($name, 'htmlStart', undef ); # beliebige HTML Strings die vor der Grafik ausgegeben werden
my $html_end = AttrVal ($name, 'htmlEnd', undef ); # beliebige HTML Strings die nach der Grafik ausgegeben werden
my $lotype = AttrVal ($name, 'layoutType', 'single' );
my $kw = AttrVal ($name, 'Wh/kWh', 'Wh' );
$height = AttrNum ($name, 'beamHeight', 200 );
my $width = AttrNum ($name, 'beamWidth', 6 ); # zu klein ist nicht problematisch
my $w = $width*$maxhours; # gesammte Breite der Ausgabe , WetterIcon braucht ca. 34px
my $fsize = AttrNum ($name, 'spaceSize', 24 );
my $maxVal = AttrNum ($name, 'maxValBeam', 0 ); # dyn. Anpassung der Balkenhöhe oder statisch ?
my $show_night = AttrNum ($name, 'showNight', 0 ); # alle Balken (Spalten) anzeigen ?
my $show_diff = AttrVal ($name, 'showDiff', 'no' ); # zusätzliche Anzeige $di{} in allen Typen
my $weather = AttrNum ($name, 'showWeather', 1 );
my $colorw = AttrVal ($name, 'weatherColor', 'FFFFFF' ); # Wetter Icon Farbe
my $colorwn = AttrVal ($name, 'weatherColorNight', $colorw ); # Wetter Icon Farbe Nacht
my $wlalias = AttrVal ($name, 'alias', $name );
my $header = AttrNum ($name, 'showHeader', 1 );
my $hdrAlign = AttrVal ($name, 'headerAlignment', 'center' ); # ermöglicht per attr die Ausrichtung der Tabelle zu setzen
my $hdrDetail = AttrVal ($name, 'headerDetail', 'all' ); # ermöglicht den Inhalt zu begrenzen, um bspw. passgenau in ftui einzubetten
# Icon Erstellung, mit @