mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-01-31 12:49:34 +00:00
915 lines
31 KiB
Perl
Executable File
915 lines
31 KiB
Perl
Executable File
########################################################################################
|
|
#
|
|
# 15_EMX.pm MUST be saved as 15_CUL_EM.pm !!!
|
|
#
|
|
# FHEM module to read the data from an EM1000 WZ/EM/GZ power sensor
|
|
#
|
|
# Prof. Dr. Peter A. Henning, 2011
|
|
#
|
|
# $Id: 15_EMX.pm 2.0 2013-02 - pahenning $
|
|
#
|
|
########################################################################################
|
|
#
|
|
# define <emx> EMX <code> <rpunit>
|
|
#
|
|
# where
|
|
# <name> may be replaced by any name string
|
|
# <code> is a number 1 - 12 or the keyword "emulator".
|
|
# <rpunit> is the scale factor = rotations per kWh or m^3 (not needed for emulator)
|
|
#
|
|
# get <name> midnight => todays starting value for counter and power meter
|
|
# get <name> cnt_midnight => todays starting value for counter
|
|
# get <name> pm_midnight => todays starting value for power meter
|
|
# get <name> month => summary of current month
|
|
#
|
|
# set <name> cnt_midnight => todays starting value for counter
|
|
# set <name> pm_midnight => todays starting value for power meter
|
|
# set <name> pm_current => current power meter reading
|
|
#
|
|
# Attributes are set as
|
|
#
|
|
# Monthly and yearly log file
|
|
# attr emx LogM EnergyM
|
|
# attr emx LogY EnergyY
|
|
#
|
|
# Basic fee per Month (€ per Month)
|
|
# attr emx CostM
|
|
#
|
|
# Cost rate during daytime (€ per kWh)
|
|
# attr emx CostD <cost rate in €/unit>
|
|
#
|
|
# Start and end of daytime cost rate - optional
|
|
# attr emx CDStart <time as hh:mm>
|
|
# attr emx CDEnd <time as hh:mm>
|
|
#
|
|
# Cost rate during nighttime (cost per unit) - only if needed
|
|
# attr emx CostN <cost rate in €/unit>
|
|
#
|
|
########################################################################################
|
|
#
|
|
# This programm is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# The GNU General Public License can be found at
|
|
# http://www.gnu.org/copyleft/gpl.html.
|
|
# A copy is found in the textfile GPL.txt and important notices to the license
|
|
# from the author is found in LICENSE.txt distributed with these scripts.
|
|
#
|
|
# This script is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
########################################################################################
|
|
package main;
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
my %gets = (
|
|
"midnight" => "",
|
|
"cnt_midnight" => "",
|
|
"pm_midnight" => "",
|
|
"month" => ""
|
|
);
|
|
|
|
my %sets = (
|
|
"cnt_midnight" => "C",
|
|
"pm_midnight" => "P",
|
|
"pm_current" => "M",
|
|
);
|
|
|
|
#-- Global variables for the raw readings
|
|
my $emx_seqno; # number of received datagram in sequence, runs from 2 to 255
|
|
my $emx_cnt; # current count from device. This value has an arbitrary offset at each start of the device
|
|
my $emx_5min; # count during last 5 min interval
|
|
my $emx_peak; # peak count during last 5 min interval
|
|
|
|
#--Forward definition
|
|
sub EMX_Parse($$);
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_Initialize
|
|
#
|
|
########################################################################################
|
|
|
|
#-- stub function for CUL_EM replacement
|
|
|
|
sub CUL_EM_Initialize ($) {
|
|
my ($hash) = @_;
|
|
|
|
return EMX_Initialize ($hash);
|
|
}
|
|
|
|
#-- real initialization function
|
|
sub EMX_Initialize ($) {
|
|
my ($hash) = @_;
|
|
|
|
$hash->{DefFn} = "EMX_Define";
|
|
$hash->{UndefFn} = "EMX_Undef";
|
|
$hash->{ParseFn} = "EMX_Parse";
|
|
$hash->{SetFn} = "EMX_Set";
|
|
$hash->{GetFn} = "EMX_Get";
|
|
$hash->{Match} = "^E0.................\$";
|
|
|
|
$hash->{AttrList} = "IODev " .
|
|
"model:EMEM,EMWZ,EMGZ loglevel LogM LogY CostD CDStart CDEnd CostN CostM ".
|
|
$readingFnAttributes;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_Define - Implements DefFn function
|
|
#
|
|
# Parameter hash, definition string
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_Define ($$) {
|
|
my ($hash, $def) = @_;
|
|
my @a = split("[ \t][ \t]*", $def);
|
|
|
|
return "wrong syntax: define <name> EMX <code> <rpunit>"
|
|
if(int(@a) < 3 || int(@a) > 4);
|
|
|
|
my $name = $a[0];
|
|
|
|
#-- emulator mode ------------------------------------------------------------
|
|
if( $a[2] eq "emulator") {
|
|
$hash->{CODE} = "emulator";
|
|
Log 1, "EMX with emulator mode";
|
|
|
|
#-- counts per unit etc.
|
|
$hash->{READINGS}{"energy"}{FACTOR} = 150;
|
|
$hash->{READINGS}{"energy"}{UNIT} = "Kilowattstunden";
|
|
$hash->{READINGS}{"energy"}{UNITABBR}= "kWh";
|
|
$hash->{READINGS}{"power"}{PERIOD} = "h";
|
|
$hash->{READINGS}{"power"}{UNIT} = "Kilowatt";
|
|
$hash->{READINGS}{"power"}{UNITABBR} = "kW";
|
|
CommandAttr(undef,"$name model emulator");
|
|
|
|
#-- set/ get artificial data
|
|
my $msg=EMX_emu(0,12345);
|
|
$hash->{READINGS}{"count"}{midnight} = 12345;
|
|
$hash->{READINGS}{"pmeter"}{midnight} = 0;
|
|
EMX_store($hash);
|
|
$hash->{emumsg}=$msg;
|
|
|
|
$modules{EMX}{defptr}{0} = $hash;
|
|
|
|
# Call emulator in 15 seconds again, and then cyclic repetition
|
|
InternalTimer(gettimeofday()+15, "EMX_Parse", $hash, 0);
|
|
|
|
} else {
|
|
#-- Real device definition -----------------------------------------------------
|
|
return "EMX_Define $a[0]: wrong CODE format: valid is 1-12 or \"emulator\""
|
|
if( $a[2] !~ m/^\d+$/ || $a[2] < 1 || $a[2] > 12 );
|
|
$hash->{CODE} = $a[2];
|
|
|
|
#--counts per unit etc.
|
|
if($a[2] >= 1 && $a[2] <= 4) { # EMWZ
|
|
$hash->{READINGS}{"energy"}{FACTOR} = $a[3];
|
|
$hash->{READINGS}{"energy"}{UNIT} = "Kilowattstunden";
|
|
$hash->{READINGS}{"energy"}{UNITABBR} = "kWh";
|
|
$hash->{READINGS}{"power"}{PERIOD} = "h";
|
|
$hash->{READINGS}{"power"}{UNIT} = "Kilowatt";
|
|
$hash->{READINGS}{"power"}{UNITABBR} = "kW";
|
|
CommandAttr (undef,"$name model EMWZ");
|
|
} elsif($a[2] >= 5 && $a[2] <= 8) { # EMEM
|
|
$hash->{READINGS}{"energy"}{FACTOR} = $a[3];
|
|
$hash->{READINGS}{"energy"}{UNIT} = "Kilowattstunden";
|
|
$hash->{READINGS}{"energy"}{UNITABBR} = "kWh";
|
|
$hash->{READINGS}{"power"}{PERIOD} = "h";
|
|
$hash->{READINGS}{"power"}{UNIT} = "Kilowatt";
|
|
$hash->{READINGS}{"power"}{UNITABBR} = "kW";
|
|
CommandAttr (undef,"$name model EMEM");
|
|
} elsif($a[2] >= 9 && $a[2] <= 12) { # EMGZ
|
|
$hash->{READINGS}{"energy"}{FACTOR} = $a[3];
|
|
$hash->{READINGS}{"energy"}{UNIT} = "Kubikmeter";
|
|
$hash->{READINGS}{"energy"}{UNITABBR} = "m^3";
|
|
$hash->{READINGS}{"power"}{PERIOD} = "h";
|
|
$hash->{READINGS}{"power"}{UNIT} = "Kubikmeter/Stunde";
|
|
$hash->{READINGS}{"power"}{UNITABBR} = "m^3/h";
|
|
CommandAttr (undef,"$name model EMGZ");
|
|
}
|
|
|
|
#-- Couple to I/O device
|
|
$modules{EMX}{defptr}{$a[2]} = $hash;
|
|
AssignIoPort($hash);
|
|
}
|
|
|
|
readingsSingleUpdate($hash,"state","defined",1);
|
|
Log 3, "EMX: Device $name defined.";
|
|
#-- Start timer for initialization in a few seconds
|
|
InternalTimer(time()+3, "EMX_InitializeDevice", $hash, 0);
|
|
return undef;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_InitializeDevice - Sets up the device after start
|
|
#
|
|
# Parameter hash
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_InitializeDevice ($) {
|
|
my ($hash) = @_;
|
|
|
|
my $ret;
|
|
|
|
my $name = $hash->{NAME};
|
|
Log 1,"EMX_InitializeDevice $name";
|
|
|
|
#-- read starting value of the day
|
|
$ret = EMX_recall($hash);
|
|
Log 1, $ret
|
|
if( defined($ret));
|
|
return $ret
|
|
if( defined($ret));
|
|
|
|
return undef;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_FormatValues - Calculate display values
|
|
#
|
|
# Parameter hash
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_FormatValues ($) {
|
|
my ($hash) = @_;
|
|
|
|
#Log 1," seqno $emx_seqno cnt $emx_cnt 5min $emx_5min peak $emx_peak";
|
|
|
|
my $name = $hash->{NAME};
|
|
my ($model,$factor,$period,$unit,$runit,$midnight,$cval,$vval,$tval,$rval,$pval,$dval,$deltim,$delcnt,$msg);
|
|
my ($svalue,$dvalue,$mvalue) = ("","","");
|
|
my $cost = 0;
|
|
|
|
my ($sec, $min, $hour, $day, $month, $year, $wday,$yday,$isdst) = localtime(time);
|
|
my ($seco,$mino,$houro,$dayo,$montho,$yearo,$dayrest);
|
|
my $daybreak = 0;
|
|
my $monthbreak = 0;
|
|
|
|
#-- Check, whether we have a new "day"
|
|
# emulator: less than 15 seconds from 5-minute period
|
|
if( $hash->{CODE} eq "emulator"){
|
|
$deltim = $min%5+$sec/60.0 - 4.75;
|
|
if( $deltim>0 ){
|
|
$yearo = $year+1900;
|
|
$montho = $month;
|
|
$dayo = $day."-".$hour."-".$min."-".$sec;
|
|
$daybreak = 1;
|
|
#-- Check, whether we have a new "month" = three 5 minute periods
|
|
if( $min%15 == 0){
|
|
$monthbreak = 1;
|
|
}
|
|
}
|
|
# normal mode: less than 5 minutes from midnight
|
|
}else {
|
|
$deltim = $hour*60.0+$min+$sec/60.0 - 1435.0;
|
|
if( $deltim>=0 ){
|
|
$daybreak = 1;
|
|
#-- Timer data from tomorrow
|
|
my ($secn,$minn,$hourn,$dayn,$monthn,$yearn,$wdayn,$ydayn,$isdstn) = localtime(time() + 3600);
|
|
#-- Check, whether we have a new month
|
|
if( $dayn == 1 ){
|
|
$monthbreak = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
$model = $main::attr{$name}{"model"};
|
|
$midnight = $hash->{READINGS}{"count"}{midnight};
|
|
$factor = $hash->{READINGS}{"energy"}{FACTOR};
|
|
$unit = $hash->{READINGS}{"energy"}{UNITABBR};
|
|
$period = $hash->{READINGS}{"power"}{PERIOD};
|
|
$runit = $hash->{READINGS}{"power"}{UNITABBR};
|
|
|
|
my $emx_cnt_prev;
|
|
my $emx_cnt_tim;
|
|
|
|
#-- skip some things if undefined
|
|
if( $emx_cnt eq ""){
|
|
$svalue = "???";
|
|
}else {
|
|
#-- put into READINGS
|
|
readingsBeginUpdate($hash);
|
|
$svalue = "raw $emx_cnt";
|
|
|
|
#-- get the old values (raw counts, always integer)
|
|
$emx_cnt_prev = $hash->{READINGS}{"count"}{VAL};
|
|
$emx_cnt_tim = $hash->{READINGS}{"count"}{TIME};
|
|
$emx_cnt_tim = "" if(!defined($emx_cnt_tim));
|
|
|
|
#-- safeguard against the case where no previous measurement
|
|
if( length($emx_cnt_tim) > 0 ){
|
|
|
|
#-- correct counter wraparound since last reading
|
|
if( $emx_cnt < $emx_cnt_prev) {
|
|
$emx_cnt_prev -= 65536;
|
|
}
|
|
#-- correct counter wraparound since last day
|
|
if( $emx_cnt < $midnight) {
|
|
$midnight -= 65536;
|
|
}
|
|
|
|
#-- For this calculation we could use either $emx_5min
|
|
# or ($emx_cnt - $emx_cnt_prev) since they are the same.
|
|
# But careful: we cannot be sure that measurement intervals are really
|
|
# 5 minutes. Differ up to a second per interval !
|
|
# Affects the rate by 0.3%, absolute count is not affected
|
|
my $fivemin = 5.0;
|
|
my $delcnt = ($emx_cnt-$emx_cnt_prev);
|
|
|
|
#-- Extrapolate these values when a new day will be started (0<deltim<5)
|
|
if( $daybreak==1 ) {
|
|
$emx_cnt += $deltim/$fivemin *$delcnt;
|
|
$cval = $emx_cnt-$midnight;
|
|
#-- no daybreak -> subtract only midnight count
|
|
}else{
|
|
$cval = $emx_cnt-$midnight;
|
|
}
|
|
#-- Translate from device into physical units
|
|
# $factor = no. of counts per unit
|
|
# $emx_peak has to be divided by 20 = 60 min/ 5 min
|
|
if( ($model eq "EMWZ") || ($model eq "emulator") ){
|
|
$vval = int($cval/$factor*1000)/1000;
|
|
$rval = int($emx_5min*12/$factor*1000)/1000;
|
|
$pval = int($emx_peak/($factor*20)*1000)/1000;
|
|
} elsif( $model eq "EMEM" ){
|
|
$vval = int($cval/($factor*10)*1000)/1000;
|
|
$rval = int($emx_5min/$factor*1000)/1000;
|
|
$pval = int($emx_peak/($factor*20)*1000)/1000;
|
|
} elsif( $model eq "EMGZ" ){
|
|
$vval = int($cval/$factor*1000)/1000;
|
|
$rval = int($emx_5min/$factor*1000)/1000;
|
|
$pval = int($emx_peak/($factor*20)*1000)/1000;
|
|
} else {
|
|
Log 3,"EMX: Wrong device model $model";
|
|
}
|
|
#-- power meter value
|
|
$tval = $vval + $hash->{READINGS}{"pmeter"}{midnight};
|
|
|
|
#-- calculate cost
|
|
if( defined($main::attr{$name}{"CostD"}) ){
|
|
#-- single rate counter
|
|
if( !defined($main::attr{$name}{"CostN"}) ){
|
|
$cost = $vval*$main::attr{$name}{"CostD"};
|
|
#-- dual rate counter
|
|
}else{
|
|
#--determine period 1 = still night, 2 = day, 3 = night again
|
|
my @crs = split(':',$main::attr{$name}{"CDStart"});
|
|
my @cre = split(':',$main::attr{$name}{"CDEnd"});
|
|
my @tim = split(/[- :]/,$emx_cnt_tim);
|
|
#-- if one of them fails, we switch to single rate mode
|
|
if( (int(@crs) ne 2) || (int(@cre) ne 2) ){
|
|
$cost = $vval*$main::attr{$name}{"CostD"};
|
|
delete $main::attr{$name}{"CostN"};
|
|
Log 3,"EMX: $name has improper cost rate time specification";
|
|
} else {
|
|
#-- period 1
|
|
if ( (($hour-$crs[0])*60 + $min-$crs[1])<0 ){
|
|
$cost = $vval*$main::attr{$name}{"CostN"};
|
|
#-- period 2
|
|
}elsif ( (($hour-$cre[0])*60 + $min-$cre[1])<0 ){
|
|
my $delta = ($tim[3]-$crs[0])*60 + ($tim[4]-$crs[1]) + $tim[5]/60.0;
|
|
my $oldval = $hash->{READINGS}{"energy"}{VAL};
|
|
#-- previous measurement was in period 1
|
|
if( $delta < 0 ){
|
|
$cost = $hash->{READINGS}{"cost"}{VAL} +
|
|
$main::attr{$name}{"CostN"}*($vval-$oldval)*(1+$delta/$fivemin)+
|
|
$main::attr{$name}{"CostD"}*($vval-$oldval)*(-$delta/$fivemin);
|
|
} else{
|
|
$cost = $hash->{READINGS}{"cost"}{VAL} + $main::attr{$name}{"CostD"}*($vval-$oldval);
|
|
}
|
|
#-- period 3
|
|
}else{
|
|
my $delta = ($tim[3]-$cre[0])*60 + ($tim[4]-$cre[1]) +$tim[5]/60.0;
|
|
my $oldval = $hash->{READINGS}{"energy"}{VAL};
|
|
#-- previous measurement was in period 2
|
|
if( $delta < 0 ){
|
|
$cost = $hash->{READINGS}{"cost"}{VAL} +
|
|
$main::attr{$name}{"CostD"}*($vval-$oldval)*(1+$delta/$fivemin)+
|
|
$main::attr{$name}{"CostN"}*($vval-$oldval)*(-$delta/$fivemin);
|
|
} else{
|
|
$cost = $hash->{READINGS}{"cost"}{VAL} + $main::attr{$name}{"CostN"}*($vval-$oldval);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$cost = floor($cost*10000+0.5)/10000;
|
|
}
|
|
|
|
#-- state format
|
|
$svalue = sprintf("W: %5.2f %s P: %5.2f %s Pmax: %5.3f %s",$vval,$unit,$rval,$runit,$pval,$runit);
|
|
#-- put into READINGS
|
|
readingsBulkUpdate($hash,"count",$emx_cnt);
|
|
readingsBulkUpdate($hash,"energy",$vval);
|
|
readingsBulkUpdate($hash,"pmeter",$tval);
|
|
readingsBulkUpdate($hash,"power",$rval);
|
|
readingsBulkUpdate($hash,"peak",$pval);
|
|
readingsBulkUpdate($hash,"cost",$cost);
|
|
|
|
#-- daybreak postprocessing
|
|
if( $daybreak == 1 ){
|
|
#-- store corrected counter value at midnight
|
|
$hash->{READINGS}{"count"}{midnight} = $emx_cnt;
|
|
$hash->{READINGS}{"pmeter"}{midnight} = $tval;
|
|
EMX_store($hash);
|
|
#-- daily/monthly accumulated value
|
|
my @monthv = EMX_GetMonth($hash);
|
|
my $total = $monthv[0]+$vval;
|
|
$dvalue = sprintf("D%02d Wd: %5.2f %s Wm: %6.2f %s Cd: %5.2f €",$day,$vval,$unit,$total,$unit,int($cost*100)/100);
|
|
readingsBulkUpdate($hash,"day",$dvalue);
|
|
if( $monthbreak == 1){
|
|
$mvalue = sprintf("M%02d Wm: %6.2f %s",$month+1,$total,$unit);
|
|
readingsBulkUpdate($hash,"month",$mvalue);
|
|
Log 1,$name." has monthbreak $msg ".$mvalue;
|
|
}
|
|
}
|
|
}
|
|
#-- STATE
|
|
readingsBulkUpdate($hash,"state",$svalue);
|
|
readingsEndUpdate($hash,1);
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_Get - Implements GetFn function
|
|
#
|
|
# Parameter hash, argument array
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_Get ($@) {
|
|
my ($hash, @a) = @_;
|
|
|
|
#-- empty argument list
|
|
return join(" ", sort keys %gets)
|
|
if(@a < 2);
|
|
|
|
#-- check syntax
|
|
my $name = $hash->{NAME};
|
|
return "EMX_Get with unknown argument $a[1], choose one of " . join(" ", sort keys %gets)
|
|
if(!defined($gets{$a[1]}));
|
|
|
|
$name = shift @a;
|
|
my $key = shift @a;
|
|
my $value;
|
|
my $ret;
|
|
|
|
#-- both midnight values
|
|
if($key eq "midnight"){
|
|
return "EMX_Get => midhight counter ".$hash->{READINGS}{"count"}{midnight}." (pmeter ".$hash->{READINGS}{"pmeter"}{midnight}.")";
|
|
}
|
|
|
|
#-- midnight counter value
|
|
if($key eq "cnt_midnight"){
|
|
$value = $hash->{READINGS}{"count"}{midnight};
|
|
}
|
|
|
|
#-- midnight power meter value
|
|
if($key eq "pm_midnight"){
|
|
$value = $hash->{READINGS}{"pmeter"}{midnight};
|
|
}
|
|
|
|
#-- monthly summary
|
|
if($key eq "month"){
|
|
my @month = EMX_GetMonth($hash);
|
|
$value = "Wm ".$month[1]." kWh (av. ".$month[2]." kWh)";
|
|
}
|
|
|
|
Log GetLogLevel($name,3), "EMX_Get => $key $value";
|
|
return "EMX_Get => $key $value";
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_Set - Implements SetFn function
|
|
#
|
|
# Parameter hash, argument array
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_Set ($@) {
|
|
my ($hash, @a) = @_;
|
|
|
|
#-- empty argument list
|
|
return join(" ", sort keys %sets)
|
|
if(@a < 3);
|
|
|
|
#-- check syntax
|
|
return "EMX_Set needs at least two parameters"
|
|
if(@a < 3);
|
|
my $name = $hash->{NAME};
|
|
Log GetLogLevel($name,3), "EMX Set request $a[1] $a[2]";
|
|
return "EMX_Set with unknown argument $a[1], choose one of " . join(" ", sort keys %sets)
|
|
if(!defined($sets{$a[1]}));
|
|
|
|
$name = shift @a;
|
|
my $key = shift @a;
|
|
my $value = join("", @a);
|
|
my $tn = TimeNow();
|
|
my $ret;
|
|
|
|
#-- value of midnight power meter reading may be set at runtime
|
|
if($key eq "pm_midnight"){
|
|
return "EMX_Set: Wrong midnight value for power meter, must be 0 <= value < 99999"
|
|
if( ($value < 0) || ($value > 99999) );
|
|
$hash->{READINGS}{"pmeter"}{midnight}=$value;
|
|
#-- store this for later usage
|
|
$ret = EMX_store($hash);
|
|
return "EMX_Set: ".$ret
|
|
if( defined($ret) );
|
|
}
|
|
|
|
#-- value of current power meter reading may be set at runtime
|
|
if($key eq "pm_current"){
|
|
return "EMX_Set: Wrong current value for power meter, must be 0 <= value < 99999"
|
|
if( ($value < 0) || ($value > 99999) );
|
|
$hash->{READINGS}{"pmeter"}{midnight}=$value-$hash->{READINGS}{"energy"}{VAL};
|
|
#-- store this for later usage
|
|
$ret = EMX_store($hash);
|
|
return "EMX_Set: ".$ret
|
|
if( defined($ret) );
|
|
}
|
|
|
|
#-- midnight counter value may be set at runtime
|
|
if( ($key eq "midnight") || ($key eq "cnt_midnight") ){
|
|
return "EMX_Set: Wrong midnight value for counter, must be -65536 <= value < 65536"
|
|
if( ($value < -65536) || ($value > 65535) );
|
|
$hash->{READINGS}{"count"}{midnight}=$value;
|
|
#-- store this for later usage
|
|
$ret = EMX_store($hash);
|
|
return "EMX_Set: ".$ret
|
|
if( defined($ret) );
|
|
}
|
|
|
|
Log GetLogLevel($name,3), "EMX_Set => $key $value";
|
|
return "EMX_Set => $key $value";
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_Undef - Implements UndefFn function
|
|
#
|
|
# Parameter hash, name
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_Undef ($$) {
|
|
my ($hash, $name) = @_;
|
|
delete($modules{EMX}{defptr}{$hash->{CODE}});
|
|
return undef;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# EMX_Parse - Parse the message string send by CUL_EM
|
|
#
|
|
# Parameter hash, msg = message string
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_Parse ($$) {
|
|
my ($hash,$msg) = @_;
|
|
|
|
if( !($msg) ) {
|
|
$msg=$hash->{emumsg};
|
|
}
|
|
|
|
# 0123456789012345678
|
|
# E01012471B80100B80B -> Type 01, Code 01, Cnt 10
|
|
my @a = split("", $msg);
|
|
my $tpe = ($a[1].$a[2])+0;
|
|
my $cde = hex($a[3].$a[4]);
|
|
|
|
#-- emulator
|
|
if( $cde eq "00"){
|
|
$cde = "emulator";
|
|
}
|
|
|
|
#-- return, if the defice is undefided
|
|
if( not($modules{EMX}{defptr}{$cde}) ){
|
|
Log 1, "EMX detected, Code $cde";
|
|
return "EMX_Parse: Undefined EMX_$cde EMX $cde";
|
|
}
|
|
|
|
my $def = $modules{EMX}{defptr}{$cde};
|
|
$hash = $def;
|
|
my $name = $hash->{NAME};
|
|
return "" if(IsIgnored($name));
|
|
|
|
$emx_seqno = hex($a[5].$a[6]);
|
|
$emx_cnt = hex($a[ 9].$a[10].$a[ 7].$a[ 8]);
|
|
$emx_5min = hex($a[13].$a[14].$a[11].$a[12]);
|
|
$emx_peak = hex($a[17].$a[18].$a[15].$a[16]);
|
|
EMX_FormatValues($hash);
|
|
|
|
#-- emulator mode - must be triggered here since not received by CUL
|
|
# Call us in 15 seconds minutes again.
|
|
if( $hash->{CODE} eq "emulator"){
|
|
# Next sequence number
|
|
$emx_seqno++;
|
|
$emx_seqno =0 if($emx_seqno > 255);
|
|
|
|
# Get artificial data
|
|
my $msg=EMX_emu($emx_seqno, $emx_cnt);
|
|
$hash->{emumsg}=$msg;
|
|
|
|
#-- restart timer for updates
|
|
RemoveInternalTimer($hash);
|
|
InternalTimer(gettimeofday()+15, "EMX_Parse", $hash,1);
|
|
}
|
|
|
|
return $hash->{NAME};
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# Store daily start value in a file
|
|
#
|
|
# Parameter hash
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_store($) {
|
|
my ($hash) = @_;
|
|
|
|
my $name = $hash->{NAME};
|
|
my $mp = AttrVal("global", "modpath", ".");
|
|
my $ret = open(EMXFILE, "> $mp/FHEM/EMX_$name.dat" );
|
|
my $msg;
|
|
if( $ret) {
|
|
#-- Timer data
|
|
my ($sec,$min,$hour,$day,$month,$year,$wday,$yday,$isdst) = localtime(time);
|
|
|
|
if( $hash->{CODE} eq "emulator"){
|
|
$msg = sprintf "%4d-%02d-%02d %02d:%02d:%02d %d %d",
|
|
$year+1900,$month+1,$day,$hour,$min,$sec,
|
|
$hash->{READINGS}{"count"}{midnight},
|
|
$hash->{READINGS}{"pmeter"}{midnight};
|
|
} else {
|
|
$msg = sprintf "%4d-%02d-%02d midnight %7.2f %7.2f",
|
|
$year+1900,$month+1,$day,
|
|
$hash->{READINGS}{"count"}{midnight},
|
|
$hash->{READINGS}{"pmeter"}{midnight};
|
|
}
|
|
print EMXFILE $msg;
|
|
Log 1, "EMX_store: $name $msg";
|
|
close(EMXFILE);
|
|
} else {
|
|
Log 1,"EMX_store: Cannot open EMX_$name.dat for writing!";
|
|
}
|
|
return undef;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# Recall daily start value from a file
|
|
#
|
|
# Parameter hash
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_recall($) {
|
|
my ($hash) = @_;
|
|
|
|
my $name= $hash->{NAME};
|
|
my $mp = AttrVal("global", "modpath", ".");
|
|
my $ret = open(EMXFILE, "< $mp/FHEM/EMX_$name.dat" );
|
|
my $msg;
|
|
if( $ret ){
|
|
my $line = readline EMXFILE;
|
|
close(EMXFILE);
|
|
my @a=split(' ',$line);
|
|
#-- Timer data from yesterday
|
|
my ($sec,$min,$hour,$day,$month,$year,$wday,$yday,$isdst) = localtime(time() - 24*60*60);
|
|
$msg = sprintf "%4d-%02d-%02d", $year+1900,$month+1,$day;
|
|
if( $msg ne $a[0]){
|
|
Log 1, "EMX_recall: midnight value $a[2] for $name not from last day, but from $a[0]";
|
|
$hash->{READINGS}{"count"}{midnight} = $a[2];
|
|
$hash->{READINGS}{"pmeter"}{midnight} = defined($a[3]) ? $a[3] : 0;
|
|
} else {
|
|
Log 1, "EMX_recall: recalled midnight value $a[2] for $name";
|
|
$hash->{READINGS}{"count"}{midnight} = $a[2];
|
|
$hash->{READINGS}{"pmeter"}{midnight} = defined($a[3]) ? $a[3] : 0;
|
|
}
|
|
} else {
|
|
Log 1, "EMX_recall: Cannot open EMX_$name.dat for reading!";
|
|
$hash->{READINGS}{"count"}{midnight}=0;
|
|
$hash->{READINGS}{"pmeter"}{midnight}=0;
|
|
}
|
|
return undef;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# Read monthly data from a file
|
|
#
|
|
# Parameter hash
|
|
#
|
|
# Returns total value up to last day, including this day and average including this day
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_GetMonth($) {
|
|
|
|
my ($hash) = @_;
|
|
my $name = $hash->{NAME};
|
|
my $regexp = ".*$name.*";
|
|
my @month;
|
|
|
|
#-- Check current logfile
|
|
my $ln = $attr{$name}{"LogM"};
|
|
if( !(defined($ln))){
|
|
Log 1,"EMX_GetMonth: Attribute LogM is missing";
|
|
return undef;
|
|
} else {
|
|
my $lf = $defs{$ln}{currentlogfile};
|
|
my $ret = open(EMXFILE, "< $lf" );
|
|
if( $ret) {
|
|
while( <EMXFILE> ){
|
|
#-- line looks like
|
|
# 2013-02-09_23:59:31 <name> day D_09 Wd: 0.00 Wm: 171.70
|
|
my $line = $_;
|
|
chomp($line);
|
|
if ( $line =~ m/$regexp/i){
|
|
my @linarr = split(' ',$line);
|
|
my $day = $linarr[3];
|
|
$day =~ s/D_0+//;
|
|
my $val = $linarr[5];
|
|
push(@month,$val);
|
|
}
|
|
}
|
|
}
|
|
#-- sum and average
|
|
my $total = 0.0;
|
|
foreach(@month){
|
|
$total +=$_;
|
|
}
|
|
#-- add data from current day
|
|
$total = int($total*100)/100;
|
|
my $total2 = int(100*($total+$hash->{READINGS}{"energy"}{VAL}))/100;
|
|
#-- number of days so far, including the present day
|
|
my ($sec,$min,$hour,$day,$month,$year,$wday,$yday,$isdst) = localtime(time);
|
|
my $deltim = int(@month)+($hour+$min/60.0 + $sec/3600.0)/24.0;
|
|
my $av = int(100*$total2/$deltim)/100;
|
|
#-- output format
|
|
return ($total,$total2,$av);
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# Emulator section - to be used, if the real device is not attached.
|
|
#
|
|
########################################################################################
|
|
|
|
sub EMX_emu ($$) {
|
|
|
|
#-- Timer data
|
|
my ($sec,$min,$hour,$day,$month,$year,$wday,$yday,$isdst) = localtime(time);
|
|
|
|
#-- parse incoming parameters
|
|
my ($seqno,$Wd_cnt_old)=@_;
|
|
|
|
#-- setup message
|
|
my $sj=sprintf("%02x",$seqno);
|
|
# power value = 0.6 from 0:00 - 06:00 / 1.8 kW from 6:00 - 22:00/1.2 kW from 22:00 - 24:00
|
|
my $Pac_cnt;
|
|
my $Wd_cnt = $Wd_cnt_old%65536;
|
|
if( ($hour+$min/60.0)<6.0 ){
|
|
$Pac_cnt= 0.64*150.0/12.0;
|
|
$Wd_cnt+= 0.64*150.0/12.0;
|
|
} elsif ( ($hour+$min/60.0)<22.0 ) {
|
|
$Pac_cnt= 1.92*150.0/12.0;
|
|
$Wd_cnt+= 1.92*150.0/12.0;
|
|
} else {
|
|
$Pac_cnt= 1.28*150.0/12.0;
|
|
$Wd_cnt+= 1.28*150.0/12.0;
|
|
}
|
|
my $cj=sprintf("%02x",int($Pac_cnt/256));
|
|
my $ck=sprintf("%02x",$Pac_cnt%256);
|
|
my $tj=sprintf("%02x",int($Wd_cnt/256));
|
|
my $tk=sprintf("%02x",$Wd_cnt%256);
|
|
|
|
my $msg="E0100".$sj.$tk.$tj.$ck.$cj."0000";
|
|
#Log 1,"cj = $cj, ck=$ck, tj=$tj, tk=$tk";
|
|
return $msg;
|
|
}
|
|
1;
|
|
|
|
=pod
|
|
=begin html
|
|
|
|
<a name="EMX"></a>
|
|
<h3>EMX</h3>
|
|
<p>FHEM module to commmunicate with the EM1000 WZ/EM/GZ power/gas sensors <br />
|
|
<br /> <b>NOTE:</b> This module is currently NOT registered in the client list of 00_CUL.pm.
|
|
Therefore ist must be saved under the name 15_CUL_EM.pm or entered into the client list manually.
|
|
<br /></p>
|
|
<br /><h4>Example</h4>
|
|
<p>
|
|
<code>define E_Verbrauch EMX 1 75</code>
|
|
</p>
|
|
<br />
|
|
<a name="EMXdefine"></a>
|
|
<h4>Define</h4>
|
|
<p>
|
|
<code>define <name> EMX <code> <rpunit></code> or <br/>
|
|
<code>define <name> EMX emulator</code>
|
|
<br /><br /> Define an EMX device or an emulated EM1000-WZ device <br /><br />
|
|
|
|
</p>
|
|
<ul>
|
|
<li>
|
|
<code><code></code><br /> Defines the sensor model, currently the following values are permitted:
|
|
<ul>
|
|
<li>1 .. 4: EM1000-WZ power meter sensor => unit is kWh</li>
|
|
<li>5 .. 8: EM1000-EM power sensor => unit is kWh</li>
|
|
<li>9 .. 12: EM1000-GZ gas meter sensor => unit is m<sup>3</sup></li>
|
|
</ul>
|
|
</li>
|
|
<li>
|
|
<code><rpunit></code><br/>Factor to scale the reading into units
|
|
<ul>
|
|
<li>EM1000-WZ devices: rotations per kWh, usually 75 or 150</li>
|
|
<li>EM1000-EM devices: digits per kWh, usually 100</li>
|
|
<li>EM1000-GZ devices: digits per <sup>3</sup>, usually 100</li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
<a name="EMXset"></a>
|
|
<h4>Set</h4>
|
|
<ul>
|
|
<li><a name="emx_cnt_midnight">
|
|
<code>set <name> cnt_midnight <int></code></a><br /> Midnight Value of internal counter </li>
|
|
<li><a name="emx_pm_midnight">
|
|
<code>set <name> pm_midnight <int></code></a><br /> Midnight value of external power meter</li>
|
|
<li><a name="emx_pmeter">
|
|
<code>set <name> pm_current <int></code></a><br /> Current value of external power meter</li>
|
|
</ul>
|
|
<br />
|
|
<a name="EMXget"></a>
|
|
<h4>Get</h4>
|
|
<ul>
|
|
<li><a name="emx_midnight">
|
|
<code>get <name> midnight</code></a>
|
|
<br /> Returns the midnight value of the counter and power meter </li>
|
|
<li><a name="emx_cnt_midnight2">
|
|
<code>get <name> cnt_midnight</code></a>
|
|
<br /> Returns the midnight value of the internal counter</li>
|
|
<li><a name="emx_pm_midnight2">
|
|
<code>get <name> pm_midnight</code></a>
|
|
<br /> Returns the midnight value of the power meter</li>
|
|
<li><a name="emx_month">
|
|
<code>get <name> month</code>
|
|
</a>
|
|
<br /> Returns a summary of the current month</li>
|
|
</ul>
|
|
<br />
|
|
<a name="EMXattr"></a>
|
|
<h4>Attributes</h4>
|
|
<ul>
|
|
<li><a name="emx_logm"><code>attr <name> <LogM>
|
|
<string></code></a>
|
|
<br />Device name (<i>not file name</i>) of the monthly logfile </li>
|
|
<li><a name="emx_logy"><code>attr <name> <LogY>
|
|
<string></code></a>
|
|
<br />Device name (<i>not file name</i>) of the yearly logfile </li>
|
|
<li><a name="emx_costm"><code>attr <name> <CostM>
|
|
<float></code></a>
|
|
<br />Cost per month</li>
|
|
<li><a name="emx_costd"><code>attr <name> <CostD>
|
|
<float></code></a>
|
|
<br />Cost per unit (during daytime, when the following attributes are given)</li>
|
|
<li><a name="emx_costn"><code>attr <name> <CostN>
|
|
<float></code></a>
|
|
<br />Cost per unit during night time</li>
|
|
<li><a name="emx_cdstart"><code>attr <name> <CDStart>
|
|
<hh:mm></code></a>
|
|
<br />Time of day when daytime cost rate starts</li>
|
|
<li><a name="emx_cdend"><code>attr <name> <CDEnd>
|
|
<hh:mm></code></a>
|
|
<br />Time of day when daytime cost rate ends</li>
|
|
<li>Standard attributes <a href="#alias">alias</a>, <a href="#comment">comment</a>, <a
|
|
href="#event-on-update-reading">event-on-update-reading</a>, <a
|
|
href="#event-on-change-reading">event-on-change-reading</a>, <a
|
|
href="#stateFormat">stateFormat</a>, <a href="#room"
|
|
>room</a>, <a href="#eventMap">eventMap</a>, <a href="#loglevel">loglevel</a>,
|
|
<a href="#webCmd">webCmd</a></li>
|
|
</ul>
|
|
|
|
=end html
|
|
=cut
|
|
|