Gleitende Mittelwerte berechnen und loggen
Für verschiedene Wettersensoren ist es oftmals wünschenswert, gleitende Mittelwerte (fälschlich auch als "relative" Mittelwerte bezeichnet) über ein bestimmtes Zeitfenster auszugeben oder in den Logs zu speichern und zu plotten. Beispiele:
- Die momentanen Winddaten eines KS300 sind oft stark schwankend. Hier wäre ein Mittelwert z.B. der letzten 2-3 Stunden interessant.
- Für die Außentemperatur ist anhand eines Mittelwertes der letzten 24 Stunden evtl. ein gewisser Trend der generellen Entwicklung der Temperatur ableitbar.
Mit Modulen wie rain oder average ist konzeptbedingt nur ein Mittelwert von fixen Zeiträumen (aktueller Tag, Monat, etc.) möglich.
Im Nachfolgenden werden deshalb zwei Programme vorgestellt, die solche gleitenden Mittelwerte bereitstellen. Beide Programme werden in die Datei 99_MyUtils.pm eingetragen und dann von FHEM aufgerufen. Das erste Programm macht dies für beliebige Readings beliebiger Devices, das zweite Programm greift auf beliebige File- oder DbLogs zurück.
Gleitender Mittelwert für beliebige Readings
Subroutine movingAverage in 99_MyUtils anlegen
Es werden die Funktionen movingAverage und movingAverageT in die 99_MyUtils Datei übernommen werden. Wenn noch nicht vorhanden, sollte die Datei dann so aussehen, der übliche Speicherort ist /opt/fhem/FHEM/99_MyUtils.pm
package main;
use strict;
use warnings;
sub
MyUtils_Initialize($$)
{
my ($hash) = @_;
}
###############################################################################
#
# Moving average
#
# Aufruf: movingAverage(devicename,readingname,zeitspanne in s)
#
###############################################################################
sub movingAverage($$$){
my ($name,$reading,$avtime) = @_;
my $hash = $defs{$name};
my @new = my ($val,$time) = ($hash->{READINGS}{$reading}{VAL},$hash->{READINGS}{$reading}{TIME});
my ($cyear, $cmonth, $cday, $chour, $cmin, $csec) = $time =~ /(\d+)-(\d+)-(\d+)\s(\d+):(\d+):(\d+)/;
my $ctime = $csec+60*$cmin+3600*$chour;
my $num;
my $arr;
#-- initialize if requested
if( ($avtime eq "-1") ){
$hash->{READINGS}{$reading}{"history"}=undef;
}
#-- test for existence
if( !$hash->{READINGS}{$reading}{"history"}){
#Log 1,"ARRAY CREATED";
push(@{$hash->{READINGS}{$reading}{"history"}},\@new);
$num = 1;
$arr=\@{$hash->{READINGS}{$reading}{"history"}};
} else {
$num = int(@{$hash->{READINGS}{$reading}{"history"}});
$arr=\@{$hash->{READINGS}{$reading}{"history"}};
my $starttime = $arr->[0][1];
my ($syear, $smonth, $sday, $shour, $smin, $ssec) = $starttime =~ /(\d+)-(\d+)-(\d+)\s(\d+):(\d+):(\d+)/;
my $stime = $ssec+60*$smin+3600*$shour;
#-- correct for daybreak
$stime-=86400
if( $stime > $ctime);
if( ($num < 25)&&( ($ctime-$stime)<$avtime) ){
#Log 1,"ARRAY has $num elements, adding another one";
push(@{$hash->{READINGS}{$reading}{"history"}},\@new);
}else{
shift(@{$hash->{READINGS}{$reading}{"history"}});
push(@{$hash->{READINGS}{$reading}{"history"}},\@new);
}
}
#-- output and average
my $average = 0;
for(my $i=0;$i<$num;$i++){
$average+=$arr->[$i][0];
Log 4,"[$name moving average] Value = ".$arr->[$i][0]." Time = ".$arr->[$i][1];
}
$average=sprintf( "%5.3f", $average/$num);
#--average
Log 4,"[$name moving average] calculated over $num values is $average";
return $average;
}
###############################################################################
#
# Moving average of last X seconds, weigh values by time
#
# movingAverageT(Devicename, Readingname, HistoryLength)
#
###############################################################################
sub movingAverageT($$$){
my ($name, $reading, $hSeconds) = @_;
my $hash = $defs{$name};
my @new = my ($val, $time) = ($hash->{READINGS}{$reading}{VAL}, $hash->{READINGS}{$reading}{TIME});
#create new hash "history" if not already existing
if ( !$hash->{READINGS}{$reading}{"history"}) {
@{$hash->{READINGS}{$reading}{"history"}} = \@new;
}
#get reference to hash "history"
my $arr = \@{$hash->{READINGS}{$reading}{"history"}};
#just add values if timestamp differs to last item in history
if( "$time" ne "$arr->[-1][1]" ) {
#append the new entry
push(@{$hash->{READINGS}{$reading}{"history"}}, \@new);
#remove entries that are too old
while( time() - time_str2num((\@{$hash->{READINGS}{$reading}{"history"}})->[0][1]) > $hSeconds ) {
#Log 1,"[$name:$reading] removing reading, it is too old";
shift(@{$hash->{READINGS}{$reading}{"history"}});
}
}
#length of current history
my $aLength = int(@{$hash->{READINGS}{$reading}{"history"}});
#if history currently consists of a single value, just return it
if ($aLength <= 1) {
#Log 1,"[$name:$reading] Average of a single value is the single value: $val";
return sprintf("%5.3f", $val);
}
#sum up all values multiplied with fraction of duration, a value that was valid longer weighs more
my $average = 0;
my $oldest = $arr->[0][1];
my $newest = $arr->[-1][1];
#Log 1,"[$name:$reading] Oldest Timestamp = ".$oldest.", Newest Timestamp: ".$newest;
$oldest = time_str2num($oldest);
$newest = time_str2num($newest);
my $timespan = $newest - $oldest;
#Log 1,"[$name:$reading] Total Timespan: ".$timespan;
#iterate of the array from index 0 to N-1
for(my $i=0; $i<$aLength-1; $i++){
#Log 1,"[$name:$reading] Index: $i, Value = ".$arr->[$i][0]." Time = ".$arr->[$i][1];
my $thisTime = time_str2num($arr->[$i][1]);
my $nextTime = time_str2num($arr->[$i+1][1]);
my $diffTime = $nextTime - $thisTime;
my $fraction = $diffTime / $timespan;
#Log 1,"[$name:$reading] diffTime = $diffTime, Fraction: $fraction";
$average += $arr->[$i][0] * $fraction;
}
#Log 1,"[$name:$reading] Average: $average";
return sprintf("%5.3f", $average);;
}
1;
Funktion movingAverage() aufrufen und nutzen
Bei jedem Aufruf schiebt die obige Funktion den gegenwärtigen Wert sowie den Zeitpunkt eines Readings (zweiter Parameter) ans Ende eines Arrays (maximal 25 Einträge) und wirft dafür den ersten Eintrag heraus. Die Anzahl der Einträge im Array wird so gewählt, dass die Zeitpunkte der Readings größer oder gleich der gewünschten Zeitspanne für die Mittelung sind. Über diese Werte wird dann gemittelt und der Wert zurückgegeben.
Zur Anwendung empfiehlt sich, dem gewünschten Device ein userReading zu geben:
attr devicename userReadings readingname.av {movingAverage("devicename","readingname",zeitspanne)}
Dieses wird dann automatisch bei jedem neuen Wert des Readings mit dem neuen gleitenden Mittelwert über die vergangene Zeitspanne gefüllt.
Beispiel: Das Reading "pressure" des Devices "A.OWB" wird alle 5 Minuten aktualisiert. Das Device bekommt nun ein userReading:
attr A.OWB userReadings pressure.av {movingAverage("A.OWB","pressure",1800)}
Dieses schreibt bei jeder Aktualisierung von "pressure" einen neuen Eintrag in sein Array - allerdings maximal sechs Werte, dann wird immer der älteste Eintrag gelöscht. Damit ist sichergestellt, dass diese mindestens 1800 Sekunden abdecken - also sechs Einträge.
Funktion movingAverageT() aufrufen und nutzen
Bei jedem Aufruf schiebt die Funktion movingAverageT den gegenwärtigen Wert sowie den Zeitpunkt eines Readings (zweiter Parameter) ans Ende eines Arrays und verwirft Einträge die älter als das Zeitlimit aus dem dritten Parameter sind. Die Anzahl der Einträge im Array ist nicht limitiert und es wird nur anhand des Zeitstempels entschieden, ob ein Wert im Array verbleibt. Über die Werte im Array wird dann gemittelt und der Wert zurückgegeben.
Zur Anwendung empfiehlt sich, dem gewünschten Device ein userReading zu geben:
attr devicename userReadings readingname.av {movingAverageT("devicename", "readingname", Zeitspanne_in_Sekunden)}
Dieses wird dann automatisch bei jedem neuen Wert des Readings mit dem neuen gleitenden Mittelwert über die vergangene Zeitspanne gefüllt.
Beispiel: Das Reading "pressure" des Devices "A.OWB" wird alle 5 Minuten aktualisiert. Das Device bekommt nun ein userReading:
attr A.OWB userReadings pressure.av {movingAverageT("A.OWB", "pressure", 1800)}
Dieses schreibt bei jeder Aktualisierung von "pressure" einen neuen Eintrag an das ende seines Array und löscht zu alte Werte am Anfang des Array wieder heraus.
Gleitender Mittelwert aus Log-Dateien
Subroutine myAverage() in 99_MyUtils anlegen
Zuerst muss die Subroutine myAverage in die 99_MyUtils übernommen werden. Wenn noch nicht vorhanden, sollte die Datei dann so aussehen:
package main;
use strict;
use warnings;
sub
MyUtils_Initialize($$)
{
my ($hash) = @_;
}
##########################################################
# myAverage
# berechnet den Mittelwert aus LogFiles über einen beliebigen Zeitraum
# Args: $offset = Offset in Sekunden
# $logfile = LogFile, z.B. DbLog Device
# $cspec = column-spec, z.B. 4:temp:: (4.Spalte, Zeile enthält temp)
sub myAverage($$$) {
my ($offset,$logfile,$cspec) = @_;
my $period_s = strftime "%Y-%m-%d\x5f%H:%M:%S", localtime(time-$offset);
my $period_e = strftime "%Y-%m-%d\x5f%H:%M:%S", localtime;
my $oll = $attr{global}{verbose};
$attr{global}{verbose} = 0;
my @logdata = split("\n", fhem("get $logfile - - $period_s $period_e $cspec"));
$attr{global}{verbose} = $oll;
my ($cnt, $cum, $avg) = (0)x3;
foreach (@logdata){
my @line = split(" ", $_);
if(defined $line[1] && $line[1] ne ""){
$cnt += 1;
$cum += $line[1];
}
}
if("$cnt" > 0){$avg = sprintf("%0.1f", $cum/$cnt)};
Log 4, ("myAverage: File: $logfile, Field: $cspec, Period: $period_s bis $period_e, Count: $cnt, Cum: $cum, Average: $avg");
return $avg;
}
##########################################################
1;
Funktion myAverage() aufrufen und nutzen
Jetzt kann die Funktion myAverage(<offset>, <logfile>, <column-spec>) ganz normal auf der FHEM-Konsole (telnet localhost 7072) genutzt werden. Hier z.B. die Ausgabe des Mittelwertes des Windsensors, eines KS300, über die letzten drei Stunden (Angabe in 3*3600s) oder der Temperaturmittelwert der letzten 24 Stunden.
Mit FileLog:
fhem> {myAverage("10800", "FileLog_KS300", "8:::")}
6.3
fhem> {myAverage("86400", "FileLog_KS300", "4:::")}
-2.7
fhem>
Mit DbLog:
fhem> {myAverage("10800", "myDbLog", "KS300:wind::")}
5.9
fhem> {myAverage("86400", "myDbLog", "KS300:temperature::")}
-2.7
fhem>
Ähnlich ist die Verwendung in perl-Code in der fhem.cfg:
my $avg = myAverage("10800", "FileLog_KS300", "8:::");;\
Ein notify, welches bei jedem neuen Sensorwert die Mitteltemperatur der letzten 24 Stunden als Event "average-temp xy" ins Logfile schreibt, sieht dann wie folgt aus:
define KS300_T_notify notify KS300:temperature.* {\
fhem('trigger KS300 average-temp: '.myAverage("86400", "FileLog_KS300", "4:::"));;\
}
Analog dazu wäre mit den Winddaten zu verfahren.
Gleitender Mittelwert und Minimum und Maximum aus Log-Dateien
Manchmal interessieren einem auch Minimum und Maximum Werte über einen bestimmten Zeitraum, die Funktion myAverage kann einfach entsprechend abgeändert werden:
Subroutine avgMinMaxAusLog() in 99_MyUtils anlegen
# Berechnet den Mittelwert, Minimum und Maximum aus LogFiles über einen beliebigen Zeitraum
# Args: $offset = Offset in Sekunden
# $logfile = LogFile, z.B. DbLog Device
# $cspec = column-spec, siehe https://fhem.de/commandref_DE.html#DbLog -> get
sub avgMinMaxAusLog($$$) {
my($offset, $logfile, $cspec) = @_;
my $period_s = strftime "%Y-%m-%d\x5f%H:%M:%S", localtime(time - $offset);
my $period_e = strftime "%Y-%m-%d\x5f%H:%M:%S", localtime;
my $oll = $attr { global } { verbose };
$attr { global } { verbose } = 0;
my @logdata = split("\n", fhem("get $logfile - - $period_s $period_e $cspec"));
$attr { global } { verbose } = $oll;
my ($cnt, $cum, $avg, $min, $max) = (0)x5;
foreach(@logdata) {
my @line = split(" ", $_);
if (defined $line[1] && $line[1] ne "") {
$cnt += 1;
$cum += $line[1];
# Beim ersten Eintrag min/max setzen
if ($cnt == 1) {
$min = $line[1];
$max = $line[1];
# Bei den darauffolgenden Einträgen $min/max ermitteln
} else {
if ($line[1] < $min) { $min = $line[1]; }
if ($line[1] > $max) { $max = $line[1]; }
}
}
}
if ("$cnt" > 0) {
$avg = sprintf("%0.1f", $cum / $cnt)
};
Log 4, ("avgMinMaxAusLog: File: $logfile, Field: $cspec, Period: $period_s bis $period_e, Count: $cnt, Cum: $cum, Average: $avg, Minimum: $min, Maximum: $max");
return ($avg, $min, $max);
}
Anwendung wie oben. Statt nur dem Mittelwert wird eine Liste zurückgeliefert mit Mittelwert, Minimum und Maximum. Verwendung z.B. wie folgt:
my ($avg, $min, $max) = myAverage("10800", "FileLog_KS300", "8:::");;\
Eigenes Filelog und Plot
Definitionen
Ich schreibe ein komplett eigenes Logfile und lasse über eine spezielle gplot-Definition die Temperatur- und Winddaten loggen und plotten.
define KS300_W dummy
define KS300_W_notify notify KS300:wind.* {\
my $avg = myAverage("10800", "FileLog_KS300", "8:::");;\
my $event = sprintf("Wc: %0.1f Wd: %0.1f Wm: %0.1f Wlh: %0.1f", ReadingsVal("KS300","wind","0"), ReadingsVal("KS300","W_avg_day","0"), ReadingsVal("KS300","W_avg_month","0"), $avg);;\
Log 2, ("K300_W: Event: $event");;\
fhem("trigger KS300_W data: $event");;\
fhem("trigger KS300 average-wind: $avg");;\
}
define FileLog_KS300_W FileLog ./log/KS300_W-%Y.log KS300_W.*
attr FileLog_KS300_W logtype text
attr FileLog_KS300_W room Logs
define KS300_TH dummy
define KS300_TH_notify notify KS300:temperature.* {\
my $avg = myAverage("86400", "FileLog_KS300", "4:::");;\
my $event = sprintf("Tc: %0.1f Hc: %0.1f Tavg: %0.1f", ReadingsVal("KS300","temperature","0"), ReadingsVal("KS300","humidity","0"), $avg);;\
Log 2, ("K300_TH: Event: $event");;\
fhem("trigger KS300_TH data: $event");;\
fhem('trigger KS300 average-temp: '.$avg);;\
}
define FileLog_KS300_TH FileLog ./log/KS300_TH-%Y.log KS300_TH.*
attr FileLog_KS300_TH logtype text
attr FileLog_KS300_TH room Logs</nowiki>
Die Definitionen für die Plots schauen so aus:
<nowiki>define weblink_KS300_W weblink fileplot FileLog_KS300_W:ks300_wind:CURRENT
attr weblink_KS300_W label "Wind - Min: $data{min1}, Max: $data{max1}, Last: $data{currval1}"
attr weblink_KS300_W room Dachterasse
define weblink_KS300_TH weblink fileplot FileLog_KS300_TH:ks300_temphum:CURRENT
attr weblink_KS300_TH label "Temperatur/Feuchte - Min: $data{min1}, Max: $data{max1}, Last: $data{currval1}"
attr weblink_KS300_TH room Dachterasse
define weblink_KS300_R weblink fileplot FileLog_KS300:ks300_rain10:CURRENT
attr weblink_KS300_R label "Regen - Min: $data{min1}, Max: $data{max1}, Last: $data{currval1}"
attr weblink_KS300_R room Dachterasse
Angepasste gplot-Dateien
Nun noch die speziellen gplot-Dateien. ks300_wind.gplot
############################
# Display the wind values of a KS300.
# Corresponding FileLog definition:
# define <filelogname> FileLog ./log/KS300_W-%Y.log KS300_W.*
set terminal png transparent size <SIZE> crop
set output '<OUT>.png'
set xdata time
set timefmt "%Y-%m-%d_%H:%M:%S"
set xlabel " "
set ytics nomirror
#set y2tics
set ytics
set title '<L1>'
set grid xtics ytics
set yrange [0:]
set y2range [0:]
set ylabel "Wind (aktuell) [km/h]"
set y2label "Wind (gemittelt) [km/h]"
set format y2 "%0.1f"
#FileLog 5:Wc\x3a:0:
#FileLog 11:Wlh\x3a:0:
plot "<IN>" using 1:5 ls l7fill axes x1y1 title 'Wind (aktuell)' with lines,\
"<IN>" using 1:11 ls l5 axes x1y2 title 'Wind (3h-Mittel)' with steps,\
ks300_temphum.gplot
############################
# Display the Temperature und Humidity values of a KS300.
# Corresponding FileLog definition:
# define <filelogname> FileLog ./log/KS300_TH-%Y.log KS300_TH.*
set terminal png transparent size <SIZE> crop
set output '<OUT>.png'
set xdata time
set timefmt "%Y-%m-%d_%H:%M:%S"
set xlabel " "
set ytics nomirror
set y2tics
#set ytics
set title '<L1>'
set grid xtics y2tics
set y2label "Temperatur [°C]"
set ylabel "Luftfeuchte [%]"
#FileLog 5:Tc\x3a:0:
#FileLog 9:Tavg\x3a:0:
#FileLog 7:Hc\x3a:0:
plot "<IN>" using 1:5 axes x1y2 ls l0 title 'Temperatur' with lines,\
"<IN>" using 1:9 axes x1y2 ls l10 title 'Temperatur (24h-Mittel)' with lines,\
"<IN>" using 1:7 axes x1y1 ls l2fill title 'Luftfeuchte' with lines
Den Plot für den Regen habe ich noch um Punkt-Plots für den israining-Status erweitert, so dass Punkte bei "yes" geplottet werden.
ks300_rain10.gplot
############################
# Display the Rain values of a KS300.
# Corresponding FileLog definition:
# define <filelogname> FileLog ./log/KS300-%Y.log KS300:T:.*
set terminal png transparent size <SIZE> crop
set output '<OUT>.png'
set xdata time
set timefmt "%Y-%m-%d_%H:%M:%S"
set xlabel " "
set ytics nomirror
#set y2tics
set ytics
set title '<L1>'
set grid xtics ytics
set y2range [0.5:1.5]
set y2tics ("" 0, "Regen" 1)
set pointsize 7
set ylabel "Regen (l/m²)"
set yrange [0:]
# Computing Rain/h and Rain/d values by accumulating the changes.
#FileLog 10:IR\x3a:0:delta-h
#FileLog 10:IR\x3a:0:delta-d
#FileLog 12:IR:0:$fld[11]=~"yes"?1:0
plot "<grep -v avg_ <IN> | perl -ane '\
@a = split(\"[_:]\", $F[0]);\
if(defined($lh) && $lh ne $a[1])\
{ printf(\"${ld}_$lh:30:00 %f\n\", $hv); $hv = 0; }\
if($lv) { $hv += ($F[9]-$lv); }\
$lh = $a[1]; $ld = $a[0]; $lv = $F[9];\
END { printf(\"${ld}_$lh:30:00 %f\n\", $hv) }'"\
using 1:2 axes x1y1 ls l1fill title 'Regen pro Stunde' with histeps,\
"<grep -v avg_ <IN> | perl -ane '\
@a = split(\"[_]\", $F[0]);\
if(defined($ld) && $ld ne $a[0]) {\
printf(\"${ld}_12:00:00 %f\n\", $dv); $dv = 0; }\
if($lv) { $dv += ($F[9]-$lv); }\
$ld = $a[0]; $lv = $F[9];\
END {printf(\"${ld}_12:00:00 %f\n\", $dv)}'"\
using 1:2 axes x1y1 ls l7 title 'Regen pro Tag' with histeps
"<grep -v avg_ <IN> | awk '{print $1, $12==\"yes\"? 1 : 0; }'"\
using 1:2 axes x1y2 ls l11fill title 'Regen aktuell' with points
Eventuell müssen in den gplots noch die Linienstile/Farben den eigenen Bedürfnissen angepasst werden. Ich verwende hier eigene Farben und Füllungen.