mirror of
https://github.com/fhem/fhem-mirror.git
synced 2024-06-17 05:40:11 +00:00
e1f9b3bc9f
git-svn-id: https://svn.fhem.de/fhem/trunk/fhem@20592 2b470e98-0d58-463d-a4d8-8e2adae1ed80
461 lines
12 KiB
Perl
461 lines
12 KiB
Perl
################################################################################
|
|
#
|
|
# $Id$
|
|
#
|
|
# 66_EseraCount.pm
|
|
#
|
|
# Copyright (C) 2019 pizmus
|
|
#
|
|
# This program 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 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program 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.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
#
|
|
################################################################################
|
|
#
|
|
# This FHEM module supports DS2423 counters.
|
|
#
|
|
################################################################################
|
|
|
|
package main;
|
|
|
|
use strict;
|
|
use warnings;
|
|
use SetExtensions;
|
|
|
|
sub
|
|
EseraCount_Initialize($)
|
|
{
|
|
my ($hash) = @_;
|
|
$hash->{Match} = "DS2423";
|
|
$hash->{DefFn} = "EseraCount_Define";
|
|
$hash->{UndefFn} = "EseraCount_Undef";
|
|
$hash->{ParseFn} = "EseraCount_Parse";
|
|
$hash->{SetFn} = "EseraCount_Set";
|
|
$hash->{GetFn} = "EseraCount_Get";
|
|
$hash->{AttrFn} = "EseraCount_Attr";
|
|
$hash->{AttrList} = "ticksPerUnit1 ticksPerUnit2 movingAverageFactor1 movingAverageFactor2 movingAverageCount1 movingAverageCount2 $readingFnAttributes";
|
|
}
|
|
|
|
sub
|
|
EseraCount_Define($$)
|
|
{
|
|
my ($hash, $def) = @_;
|
|
my @a = split( "[ \t][ \t]*", $def);
|
|
|
|
return "Usage: define <name> EseraCount <physicalDevice> <1-wire-ID> <deviceType>" if(@a < 5);
|
|
|
|
my $devName = $a[0];
|
|
my $type = $a[1];
|
|
my $physicalDevice = $a[2];
|
|
my $oneWireId = $a[3];
|
|
my $deviceType = uc($a[4]);
|
|
|
|
$hash->{STATE} = 'Initialized';
|
|
$hash->{NAME} = $devName;
|
|
$hash->{TYPE} = $type;
|
|
$hash->{ONEWIREID} = $oneWireId;
|
|
$hash->{ESERAID} = undef; # We will get this from the first reading.
|
|
$hash->{DEVICE_TYPE} = $deviceType;
|
|
$hash->{DATE_OF_LAST_SAMPLE} = undef;
|
|
$hash->{START_VALUE_OF_DAY_1} = 0;
|
|
$hash->{START_VALUE_OF_DAY_2} = 0;
|
|
$hash->{LAST_VALUE_1} = 0;
|
|
$hash->{LAST_VALUE_2} = 0;
|
|
|
|
$modules{EseraCount}{defptr}{$oneWireId} = $hash;
|
|
|
|
AssignIoPort($hash, $physicalDevice);
|
|
|
|
if (defined($hash->{IODev}->{NAME}))
|
|
{
|
|
Log3 $devName, 4, "$devName: I/O device is " . $hash->{IODev}->{NAME};
|
|
}
|
|
else
|
|
{
|
|
Log3 $devName, 1, "$devName: no I/O device";
|
|
}
|
|
|
|
return undef;
|
|
}
|
|
|
|
sub
|
|
EseraCount_Undef($$)
|
|
{
|
|
my ($hash, $arg) = @_;
|
|
my $oneWireId = $hash->{ONEWIREID};
|
|
|
|
RemoveInternalTimer($hash);
|
|
delete( $modules{EseraCount}{defptr}{$oneWireId} );
|
|
|
|
return undef;
|
|
}
|
|
|
|
sub
|
|
EseraCount_Get($@)
|
|
{
|
|
return undef;
|
|
}
|
|
|
|
sub
|
|
EseraCount_Set($$)
|
|
{
|
|
return undef;
|
|
}
|
|
|
|
sub
|
|
EseraCount_IsNewDay($)
|
|
{
|
|
my ($hash) = @_;
|
|
|
|
my $timestamp = FmtDateTime(gettimeofday());
|
|
# example: 2016-02-16 19:34:24
|
|
|
|
if ($timestamp =~ m/^([0-9\-]+)\s/)
|
|
{
|
|
my $dateString = $1;
|
|
|
|
if (defined $hash->{DATE_OF_LAST_SAMPLE})
|
|
{
|
|
if (!($hash->{DATE_OF_LAST_SAMPLE} eq $dateString))
|
|
{
|
|
$hash->{DATE_OF_LAST_SAMPLE} = $dateString;
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$hash->{DATE_OF_LAST_SAMPLE} = $dateString;
|
|
}
|
|
}
|
|
|
|
return undef;
|
|
}
|
|
|
|
sub
|
|
EseraCount_MovingAverage($$$$)
|
|
{
|
|
my ($hash, $newValue, $averageCount, $channel) = @_;
|
|
my $name = $hash->{NAME};
|
|
|
|
Log3 $name, 5, "EseraCount ($name): averageCount $averageCount newValue $newValue";
|
|
|
|
# get array with the last samples
|
|
my @lastSamples;
|
|
my $ref;
|
|
if ($channel == 1)
|
|
{
|
|
$ref = $hash->{LAST_VALUES_1};
|
|
}
|
|
else
|
|
{
|
|
$ref = $hash->{LAST_VALUES_2};
|
|
}
|
|
if (defined $ref)
|
|
{
|
|
@lastSamples = @$ref;
|
|
}
|
|
else
|
|
{
|
|
@lastSamples = ();
|
|
}
|
|
|
|
# add new sample to front of the list
|
|
unshift(@lastSamples, $newValue);
|
|
|
|
# remove oldest sample if needed
|
|
while ((scalar @lastSamples) > $averageCount)
|
|
{
|
|
pop @lastSamples;
|
|
Log3 $name, 5, "EseraCount ($name): pop once";
|
|
}
|
|
|
|
# store new array in $hash
|
|
if ($channel == 1)
|
|
{
|
|
$hash->{LAST_VALUES_1} = \@lastSamples;
|
|
}
|
|
else
|
|
{
|
|
$hash->{LAST_VALUES_2} = \@lastSamples;
|
|
}
|
|
|
|
# calculate the average across the array
|
|
my $count = 0;
|
|
my $sum = 0;
|
|
foreach (@lastSamples)
|
|
{
|
|
$count += 1;
|
|
$sum += $_;
|
|
Log3 $name, 5, "EseraCount ($name): count $count sum $sum value $_";
|
|
}
|
|
|
|
return $sum / $count;
|
|
}
|
|
|
|
sub
|
|
EseraCount_Parse($$)
|
|
{
|
|
my ($ioHash, $msg) = @_;
|
|
my $ioName = $ioHash->{NAME};
|
|
my $buffer = $msg;
|
|
|
|
# expected message format: $deviceType."_".$oneWireId."_".$eseraId."_".$readingId."_".$value
|
|
my @fields = split(/_/, $buffer);
|
|
if (scalar(@fields) != 5)
|
|
{
|
|
return undef;
|
|
}
|
|
my $deviceType = uc($fields[0]);
|
|
my $oneWireId = $fields[1];
|
|
my $eseraId = $fields[2];
|
|
my $readingId = $fields[3];
|
|
my $value = $fields[4];
|
|
|
|
# search for logical device
|
|
my $rhash = undef;
|
|
foreach my $d (keys %defs) {
|
|
my $h = $defs{$d};
|
|
my $type = $h->{TYPE};
|
|
|
|
if($type eq "EseraCount")
|
|
{
|
|
if (defined($h->{IODev}->{NAME}))
|
|
{
|
|
my $ioDev = $h->{IODev}->{NAME};
|
|
my $def = $h->{DEF};
|
|
|
|
# $def has the whole definition, extract the oneWireId (which is expected as 2nd parameter)
|
|
my @parts = split(/ /, $def);
|
|
my $oneWireIdFromDef = $parts[1];
|
|
|
|
if (($ioDev eq $ioName) && ($oneWireIdFromDef eq $oneWireId))
|
|
{
|
|
$rhash = $h;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if($rhash) {
|
|
my $rname = $rhash->{NAME};
|
|
Log3 $rname, 4, "EseraCount ($rname) - parse - device found: ".$rname;
|
|
|
|
# capture the Esera ID for later use
|
|
$rhash->{ESERAID} = $eseraId;
|
|
|
|
# consistency check of device type
|
|
if (!($rhash->{DEVICE_TYPE} eq uc($deviceType)))
|
|
{
|
|
Log3 $rname, 1, "EseraCount ($rname) - unexpected device type ".$deviceType;
|
|
}
|
|
|
|
if ($readingId eq "ERROR")
|
|
{
|
|
Log3 $rname, 1, "EseraCount ($rname) - error message from physical device: ".$value;
|
|
}
|
|
elsif ($readingId eq "STATISTIC")
|
|
{
|
|
Log3 $rname, 1, "EseraCount ($rname) - statistics message not supported yet: ".$value;
|
|
}
|
|
else
|
|
{
|
|
if ($deviceType eq "DS2423")
|
|
{
|
|
if (EseraCount_IsNewDay($rhash))
|
|
{
|
|
$rhash->{START_VALUE_OF_DAY_1} = $rhash->{LAST_VALUE_1};
|
|
$rhash->{START_VALUE_OF_DAY_2} = $rhash->{LAST_VALUE_2};
|
|
}
|
|
|
|
if ($readingId == 1)
|
|
{
|
|
my $ticksPerUnit = AttrVal($rname, "ticksPerUnit1", 1.0);
|
|
readingsSingleUpdate($rhash, "count1", ($value / $ticksPerUnit), 1);
|
|
readingsSingleUpdate($rhash, "count1Today", ($value - $rhash->{START_VALUE_OF_DAY_1}) / $ticksPerUnit, 1);
|
|
if (defined $rhash->{LAST_VALUE_1})
|
|
{
|
|
my $movingAverageFactor = AttrVal($rname, "movingAverageFactor1", 1.0);
|
|
my $averageCount = AttrVal($rname, "movingAverageCount1", 1);
|
|
my $movingAverage = ($value - $rhash->{LAST_VALUE_1});
|
|
my $processedMovingAverage = EseraCount_MovingAverage($rhash, $movingAverage * $movingAverageFactor, $averageCount, 1);
|
|
readingsSingleUpdate($rhash, "count1MovingAverage", $processedMovingAverage, 1);
|
|
}
|
|
$rhash->{LAST_VALUE_1} = $value;
|
|
}
|
|
elsif ($readingId == 2)
|
|
{
|
|
my $ticksPerUnit = AttrVal($rname, "ticksPerUnit2", 1.0);
|
|
readingsSingleUpdate($rhash, "count2", ($value / $ticksPerUnit), 1);
|
|
readingsSingleUpdate($rhash, "count2Today", ($value - $rhash->{START_VALUE_OF_DAY_2}) / $ticksPerUnit, 1);
|
|
if (defined $rhash->{LAST_VALUE_2})
|
|
{
|
|
my $movingAverageFactor = AttrVal($rname, "movingAverageFactor2", 1.0);
|
|
my $averageCount = AttrVal($rname, "movingAverageCount2", 1);
|
|
my $movingAverage = ($value - $rhash->{LAST_VALUE_2});
|
|
my $processedMovingAverage = EseraCount_MovingAverage($rhash, $movingAverage * $movingAverageFactor, $averageCount, 2);
|
|
readingsSingleUpdate($rhash, "count2MovingAverage", $processedMovingAverage, 1);
|
|
}
|
|
$rhash->{LAST_VALUE_2} = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
my @list;
|
|
push(@list, $rname);
|
|
return @list;
|
|
}
|
|
elsif ($deviceType eq "DS2423")
|
|
{
|
|
return "UNDEFINED EseraCount_".$ioName."_".$oneWireId." EseraCount ".$ioName." ".$oneWireId." ".$deviceType;
|
|
}
|
|
|
|
return undef;
|
|
}
|
|
|
|
sub
|
|
EseraCount_Attr($$$$)
|
|
{
|
|
my ($cmd, $name, $attrName, $attrValue) = @_;
|
|
# $cmd - "del" or "set"
|
|
# $name - device name
|
|
# $attrName/$attrValue
|
|
|
|
if ($cmd eq "set") {
|
|
if (($attrName eq "ticksPerUnit1") || ($attrName eq "ticksPerUnit2"))
|
|
{
|
|
if ($attrValue <= 0)
|
|
{
|
|
my $message = "illegal value for ticksPerUnit";
|
|
Log3 $name, 3, "EseraCount ($name) - ".$message;
|
|
return $message;
|
|
}
|
|
}
|
|
if (($attrName eq "movingAverageFactor1") || ($attrName eq "movingAverageFactor2"))
|
|
{
|
|
if ($attrValue <= 0)
|
|
{
|
|
my $message = "illegal value for movingAverageFactor";
|
|
Log3 $name, 3, "EseraCount ($name) - ".$message;
|
|
return $message;
|
|
}
|
|
}
|
|
if (($attrName eq "movingAverageCount1") || ($attrName eq "movingAverageCount2"))
|
|
{
|
|
if ($attrValue < 1)
|
|
{
|
|
my $message = "illegal value for movingAverageCount";
|
|
Log3 $name, 3, "EseraCount ($name) - ".$message;
|
|
return $message;
|
|
}
|
|
}
|
|
}
|
|
|
|
return undef;
|
|
}
|
|
|
|
1;
|
|
|
|
=pod
|
|
=item summary Represents a DS2423 1-wire dual counter.
|
|
=item summary_DE Repraesentiert einen DS2423 1-wire 2-fach Zaehler.
|
|
=begin html
|
|
|
|
<a name="EseraCount"></a>
|
|
<h3>EseraCount</h3>
|
|
|
|
<ul>
|
|
This module supports DS2423 1-wire dual counters.<br>
|
|
It uses 66_EseraOneWire as I/O device.<br>
|
|
<br>
|
|
|
|
<a name="EseraCount_Define"></a>
|
|
<b>Define</b>
|
|
<ul>
|
|
<code>define <name> EseraCount <ioDevice> <oneWireId> <deviceType></code><br>
|
|
<oneWireId> specifies the 1-wire ID of the sensor. Use the "get devices" <br>
|
|
query of EseraOneWire to get a list of 1-wire IDs, or simply rely on autocreate. <br>
|
|
The only supported <deviceType> is DS2423.
|
|
</ul>
|
|
|
|
<a name="EseraCount_Set"></a>
|
|
<b>Set</b>
|
|
<ul>
|
|
<li>no get functionality</li>
|
|
</ul>
|
|
<br>
|
|
|
|
<a name="EseraCount_Get"></a>
|
|
<b>Get</b>
|
|
<ul>
|
|
<li>no get functionality</li>
|
|
</ul>
|
|
<br>
|
|
|
|
<a name="EseraCount_Attr"></a>
|
|
<b>Attributes</b>
|
|
<ul>
|
|
<li>
|
|
<code>ticksPerUnit1</code><br>
|
|
<code>ticksPerUnit2</code><br>
|
|
These attribute are applied to readings <code>count1</code> / <code>count2</code> and <br>
|
|
<code>count1Today</code> / <code>count2Today</code>.<br>
|
|
The default value is 1. The attribute is used to convert the raw<br>
|
|
tick count to meaningful value with a unit.
|
|
</li>
|
|
<li>
|
|
<code>movingAverageCount1</code><br>
|
|
<code>movingAverageCount2</code><br>
|
|
see description of reading <code>count1MovingAverage</code> and <code>count2MovingAverage</code><br>
|
|
default: 1
|
|
</li>
|
|
<li>
|
|
<code>movingAverageFactor1</code><br>
|
|
<code>movingAverageFactor2</code><br>
|
|
see description of reading <code>count1MovingAverage</code> and <code>count2MovingAverage</code><br>
|
|
default: 1
|
|
</li>
|
|
</ul>
|
|
<br>
|
|
|
|
<a name="EseraCount_Readings"></a>
|
|
<b>Readings</b>
|
|
<ul>
|
|
<li>
|
|
<code>count1</code><br>
|
|
<code>count2</code><br>
|
|
The counter values for channel 1 and 2. These are the counter values with<br>
|
|
attributes <code>ticksPerUnit1</code> and <code>ticksPerUnit2</code> applied.
|
|
</li>
|
|
<li>
|
|
<code>count1Today</code><br>
|
|
<code>count2Today</code><br>
|
|
Similar to <code>count1</code> and <code>count2</code> but with a reset at midnight.
|
|
</li>
|
|
<li>
|
|
<code>count1MovingAverage</code><br>
|
|
<code>count2MovingAverage</code><br>
|
|
Moving average of the last <code>movingAverageCount1</code> and <code>movingAverageCount2</code>samples, <br>
|
|
multiplied with <code>movingAverageFactor1</code> or <code>movingAverageFactor2</code>. This reading and <br>
|
|
the related attributes are used to derive a power value value from the S0 count of an <br>
|
|
energy meter. Samples must have a fixed and known period. This is the case with the Esera 1-wire<br>
|
|
controller. When selecting a value for <code>movingAverageFactor1</code> and <code>movingAverageFactor2</code> the sample <br>
|
|
period has to be considered.<br>
|
|
</li>
|
|
</ul>
|
|
<br>
|
|
|
|
</ul>
|
|
|
|
=end html
|
|
=cut
|