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

Zuerst muss die Subroutine movingAverage in die 99_MyUtils übernommen werden. Wenn noch nicht vorhanden, sollte die Datei dann so aussehen:

package main;
use strict;
use warnings;
use POSIX;
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;
 }


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 userReading 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 userReading 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.

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;
use POSIX;
sub
MyUtils_Initialize($$)
{
 my ($hash) = @_;
}
##########################################################
# myAverage
# berechnet den Mittelwert aus LogFiles über einen beliebigen Zeitraum
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.

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

Die Definitionen für die Plots schauen so aus:

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.