FHEM/fhem-mirror
2
0
Fork 0
mirror of https://github.com/fhem/fhem-mirror.git synced 2025-04-24 21:29:21 +00:00
Code Issues Releases Wiki Activity

git-svn-id: https://svn.fhem.de/fhem/trunk@4987 2b470e98-0d58-463d-a4d8-8e2adae1ed80

Browse Source
This commit is contained in:
pahenning 2014-02-18 19:26:48 +00:00
parent e6a70801fe
commit 1a23e2165a
5 changed files with 295 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

378
fhem/FHEM/21_OWCOUNT.pm
View File

@ -84,7 +84,7 @@ use strict;
use warnings; use warnings;
sub Log($$); sub Log($$);
my $owx_version="5.04"; my $owx_version="5.05";
#-- fixed raw channel name, flexible channel name #-- fixed raw channel name, flexible channel name
my @owg_fixed = ("A","B"); my @owg_fixed = ("A","B");
my @owg_channel = ("A","B"); my @owg_channel = ("A","B");
@ -270,20 +270,18 @@ sub OWCOUNT_Attr(@) {
my $ret; my $ret;
if ( $do eq "set") { if ( $do eq "set") {
ARGUMENT_HANDLER: { #-- interval modified at runtime
#-- interval modified at runtime $key eq "interval" and do {
$key eq "interval" and do { #-- check value
#-- check value return "OWCOUNT: Set with short interval, must be > 1" if(int($value) < 1);
return "OWCOUNT: Set with short interval, must be > 1" if(int($value) < 1); #-- update timer
#-- update timer $hash->{INTERVAL} = $value;
$hash->{INTERVAL} = $value; if ($init_done) {
if ($init_done) { RemoveInternalTimer($hash);
RemoveInternalTimer($hash); InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWCOUNT_GetValues", $hash, 1);
InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWCOUNT_GetValues", $hash, 1); }
} last;
last; };
};
}
} }
return $ret; return $ret;
} }
@ -388,8 +386,6 @@ sub OWCOUNT_FormatValues($) {
my $daybreak = 0; my $daybreak = 0;
my $monthbreak = 0; my $monthbreak = 0;
my $present = $hash->{PRESENT};
#-- no change in any value if invalid reading #-- no change in any value if invalid reading
for (my $i=0;$i<int(@owg_fixed);$i++){ for (my $i=0;$i<int(@owg_fixed);$i++){
return if( $hash->{owg_val}->[$i] eq ""); return if( $hash->{owg_val}->[$i] eq "");
@ -463,7 +459,7 @@ sub OWCOUNT_FormatValues($) {
#-- previous measurement time #-- previous measurement time
($yearo,$montho,$dayrest) = split(/-/,$oldtim); ($yearo,$montho,$dayrest) = split(/-/,$oldtim);
$dayo = substr($dayrest,0,2); $dayo = substr($dayrest,0,2);*60=
($houro,$mino,$seco) = split(/:/,substr($dayrest,3)); ($houro,$mino,$seco) = split(/:/,substr($dayrest,3));
#-- time difference to previous measurement and to midnight #-- time difference to previous measurement and to midnight
@ -471,7 +467,7 @@ sub OWCOUNT_FormatValues($) {
$delf = $hour *3600 + $min *60 + $sec - 86400; $delf = $hour *3600 + $min *60 + $sec - 86400;
#-- rate #-- rate
if( ($delt > 0.0) && $present ){ if( $delt > 0.0){
$vrate = ($vval-$oldval)/$delt; $vrate = ($vval-$oldval)/$delt;
} else { } else {
$vrate = 0.0; $vrate = 0.0;
@ -497,7 +493,9 @@ sub OWCOUNT_FormatValues($) {
} }
#-- in any mode store the interpolated value in the midnight store #-- in any mode store the interpolated value in the midnight store
OWCOUNT_SetPage($hash,14+$i,sprintf("%f",$dval2)); my $msg = sprintf("%4d-%02d-%02d midnight %7.2f",
$year+1900,$month+1,$day,$dval2);
OWCOUNT_SetPage($hash,14+$i,$msg);
#-- string buildup for monthly and yearly logging #-- string buildup for monthly and yearly logging
$dvalue .= sprintf( " %s: %5.1f %s %sM: %%5.1f %s", $owg_channel[$i],$dval,$unit,$owg_channel[$i],$unit); $dvalue .= sprintf( " %s: %5.1f %s %sM: %%5.1f %s", $owg_channel[$i],$dval,$unit,$owg_channel[$i],$unit);
@ -510,7 +508,7 @@ sub OWCOUNT_FormatValues($) {
$svalue .= sprintf( "%s: %5.1f %s %s: %5.2f %s", $owg_channel[$i], $vval,$unit,$owg_rate[$i],$vrate,$runit); $svalue .= sprintf( "%s: %5.1f %s %s: %5.2f %s", $owg_channel[$i], $vval,$unit,$owg_rate[$i],$vrate,$runit);
#-- 3 decimals #-- 3 decimals
} else { } else {
$svalue .= sprintf( "%s: %5.3f %s %s: %5.2f %s", $owg_channel[$i], $vval,$unit,$owg_rate[$i],$vrate,$runit); $svalue .= sprintf( "%s: %5.3f %s %s: %5.4f %s", $owg_channel[$i], $vval,$unit,$owg_rate[$i],$vrate,$runit);
} }
} }
readingsBulkUpdate($hash,$owg_channel[$i],$vval); readingsBulkUpdate($hash,$owg_channel[$i],$vval);
@ -617,9 +615,6 @@ sub OWCOUNT_Get($@) {
return "$name.version => $owx_version"; return "$name.version => $owx_version";
} }
#-- reset presence
$hash->{PRESENT} = 0;
#-- get channel names #-- get channel names
OWCOUNT_ChannelNames($hash); OWCOUNT_ChannelNames($hash);
@ -679,6 +674,8 @@ sub OWCOUNT_Get($@) {
return $value; return $value;
} }
#-- get memory page/counter according to interface type #-- get memory page/counter according to interface type
my $interface= $hash->{IODev}->{TYPE}; my $interface= $hash->{IODev}->{TYPE};
@ -706,13 +703,12 @@ sub OWCOUNT_Get($@) {
return "OWCOUNT: Invalid midnight counter address, must be A, B or defined channel name" return "OWCOUNT: Invalid midnight counter address, must be A, B or defined channel name"
} }
} }
$ret = OWCOUNT_GetPage($hash,$page); $ret = OWCOUNT_GetPage($hash,$page,1);
#-- when we have a return code, we have an error #-- when we have a return code, we have an error
if( $ret ){ if( $ret ){
return "OWCOUNT: Could not get values from device $name, reason: ".$ret; return "OWCOUNT: Could not get values from device $name, reason: ".$ret;
}else{ }else{
return "OWCOUNT: $name.$reading [$page] =>".$hash->{owg_str}->[$page]; return "OWCOUNT: $name.$reading [$page] =>".$hash->{owg_midnight}->[$page-14];
} }
} }
@ -728,12 +724,11 @@ sub OWCOUNT_Get($@) {
} else { } else {
return "OWCOUNT: Invalid counter address, must be A, B or defined channel name" return "OWCOUNT: Invalid counter address, must be A, B or defined channel name"
} }
$ret = OWCOUNT_GetPage($hash,$page,1);
$ret = OWCOUNT_GetPage($hash,$page); #-- when we have a return code, we have an error
if( defined($ret) ){ if( $ret ){
return "OWCOUNT: Could not get values from device $name, reason: ".$ret; return "OWCOUNT: Could not get values from device $name, reason: ".$ret;
} }
$hash->{PRESENT} = 1;
#-- only one counter will be returned #-- only one counter will be returned
return "OWCOUNT: $name.raw $a[2] => ".$hash->{owg_val}->[$page-14]; return "OWCOUNT: $name.raw $a[2] => ".$hash->{owg_val}->[$page-14];
@ -741,8 +736,8 @@ sub OWCOUNT_Get($@) {
}elsif( $reading eq "counters" ){ }elsif( $reading eq "counters" ){
return "OWCOUNT: Get needs no parameter when reading counters" return "OWCOUNT: Get needs no parameter when reading counters"
if( int(@a)==1 ); if( int(@a)==1 );
$ret1 = OWCOUNT_GetPage($hash,14); $ret1 = OWCOUNT_GetPage($hash,14,0);
$ret2 = OWCOUNT_GetPage($hash,15); $ret2 = OWCOUNT_GetPage($hash,15,1);
#-- process results #-- process results
$ret .= $ret1 $ret .= $ret1
@ -752,7 +747,6 @@ sub OWCOUNT_Get($@) {
if( defined($ret1) || defined($ret2) ){ if( defined($ret1) || defined($ret2) ){
return "OWCOUNT: Could not get values from device $name, reason: ".$ret; return "OWCOUNT: Could not get values from device $name, reason: ".$ret;
} }
$hash->{PRESENT} = 1;
#-- both counters will be returned #-- both counters will be returned
return "OWCOUNT: $name.counters => ".$hash->{READINGS}{"state"}{VAL}; return "OWCOUNT: $name.counters => ".$hash->{READINGS}{"state"}{VAL};
} }
@ -764,52 +758,63 @@ sub OWCOUNT_Get($@) {
# #
# Parameter hash = hash of device addressed # Parameter hash = hash of device addressed
# page = page addressed # page = page addressed
# final= 1 if FormatValues is to be called
# #
######################################################################################## ########################################################################################
sub OWCOUNT_GetPage ($$) { sub OWCOUNT_GetPage ($$$) {
my ($hash, $page) = @_; my ($hash, $page,$final) = @_;
#-- get memory page/counter according to interface type #-- get memory page/counter according to interface type
my $interface= $hash->{IODev}->{TYPE}; my $interface= $hash->{IODev}->{TYPE};
my $name = $hash->{NAME}; my $name = $hash->{NAME};
my $ret; my $ret;
my $oldfinal= $final;
#-- check if memory usage has been disabled #-- check if memory usage has been disabled
my $nomemory = defined($attr{$name}{"nomemory"}) ? $attr{$name}{"nomemory"} : 0; my $nomemory = defined($attr{$name}{"nomemory"}) ? $attr{$name}{"nomemory"} : 0;
$final=0
if($nomemory==1);
#-- even if memory usage has been disabled, we need to read the page because it contains the counter values #-- even if memory usage has been disabled, we need to read the page because it contains the counter values
if( ($nomemory==0) || (($nomemory==1) && ( ($page==14)||($page==15) )) ){ if( ($nomemory==0) || ($nomemory==1 && (($page==14)||($page==15))) ){
#-- OWX interface #-- OWX interface
if( $interface eq "OWX" ){ if( $interface eq "OWX" ){
$ret = OWXCOUNT_GetPage($hash,$page); $ret = OWXCOUNT_GetPage($hash,$page,$final);
#-- OWFS interface #-- OWFS interface
}elsif( $interface eq "OWServer" ){ }elsif( $interface eq "OWServer" ){
$ret = OWFSCOUNT_GetPage($hash,$page); $ret = OWFSCOUNT_GetPage($hash,$page,$final);
#-- Unknown interface #-- Unknown interface
}else{ }else{
return "OWCOUNT: GetPage with wrong IODev type $interface"; return "OWCOUNT: GetPage with wrong IODev type $interface";
} }
#-- process results #-- process results
if( defined($ret) ){ if( defined($ret) ){
return "OWCOUNT: Could not get values from device $name, reason: ".$ret; return "OWCOUNT: Could not get values from device $name, reason: ".$ret;
} else { } else {
return undef return undef
if( $nomemory==0 ); if ($nomemory==0);
} }
#-- when nomemory==1, we need to read the files
if( $page==14 ){
$hash->{owg_str}->[14] = OWCOUNT_recall($hash,"OWCOUNT_".$name."_14.dat");
return undef;
}elsif( $page==15 ){
$hash->{owg_str}->[15] = OWCOUNT_recall($hash,"OWCOUNT_".$name."_15.dat");
return undef;
} else {
return "OWCOUNT: file recall with wrong page number";
}
} }
#-- when we are here, we need to read the files
my $strval = OWCOUNT_recall($hash,"OWCOUNT_".$name."_".$page.".dat");
#-- midnight value
#-- new format
if ($strval =~ /^\d\d\d\d-\d\d-\d\d.*/){
my @data=split(' ',$strval);
$strval = $data[2];
}
#-- parse float from midnight
$strval =~ s/[^\d\.]+//g;
$strval = 0.0 if(!defined($strval) or $strval !~ /^\d+\.\d*$/);
$strval = int($strval*100)/100;
$hash->{owg_midnight}->[$page-14] = $strval;
OWCOUNT_FormatValues($hash)
if($oldfinal==1);
return undef
} }
######################################################################################## ########################################################################################
@ -1038,17 +1043,14 @@ sub OWCOUNT_GetValues($) {
RemoveInternalTimer($hash); RemoveInternalTimer($hash);
InternalTimer(time()+$hash->{INTERVAL}, "OWCOUNT_GetValues", $hash, 1); InternalTimer(time()+$hash->{INTERVAL}, "OWCOUNT_GetValues", $hash, 1);
#-- reset presence -
$hash->{PRESENT} = 0;
#-- Get readings according to interface type #-- Get readings according to interface type
my $interface= $hash->{IODev}->{TYPE}; my $interface= $hash->{IODev}->{TYPE};
if( $interface eq "OWX" ){ if( $interface eq "OWX" ){
$ret1 = OWXCOUNT_GetPage($hash,14); $ret1 = OWXCOUNT_GetPage($hash,14,0);
$ret2 = OWXCOUNT_GetPage($hash,15); $ret2 = OWXCOUNT_GetPage($hash,15,1);
}elsif( $interface eq "OWServer" ){ }elsif( $interface eq "OWServer" ){
$ret1 = OWFSCOUNT_GetPage($hash,14); $ret1 = OWFSCOUNT_GetPage($hash,14,0);
$ret2 = OWFSCOUNT_GetPage($hash,15); $ret2 = OWFSCOUNT_GetPage($hash,15,1);
}else{ }else{
return "OWCOUNT: GetValues with wrong IODev type $interface"; return "OWCOUNT: GetValues with wrong IODev type $interface";
} }
@ -1061,7 +1063,6 @@ sub OWCOUNT_GetValues($) {
if( $ret ne "" ){ if( $ret ne "" ){
return "OWCOUNT: Could not get values from device $name, reason: ".$ret; return "OWCOUNT: Could not get values from device $name, reason: ".$ret;
} }
$hash->{PRESENT} = 1;
return undef; return undef;
} }
@ -1083,8 +1084,7 @@ sub OWCOUNT_InitializeDevice($) {
my $olddata = ""; my $olddata = "";
my $newdata = "OWCOUNT ".$owx_version; my $newdata = "OWCOUNT ".$owx_version;
my $ret = ""; my $ret;
$hash->{PRESENT} = 0;
#-- initial values #-- initial values
for( my $i=0;$i<int(@owg_fixed);$i++) { for( my $i=0;$i<int(@owg_fixed);$i++) {
@ -1101,24 +1101,19 @@ sub OWCOUNT_InitializeDevice($) {
# Model attribute will be modified now after checking for memory # Model attribute will be modified now after checking for memory
#-- OWX interface #-- OWX interface
if( $interface eq "OWX" ){ if( $interface eq "OWX" ){
$ret .= OWXCOUNT_GetPage($hash,0); $ret = OWXCOUNT_GetPage($hash,0,0);
$olddata = $hash->{owg_str}->[0]; $olddata = $hash->{owg_str}->[0];
$ret = OWXCOUNT_SetPage($hash,0,$newdata); $ret = OWXCOUNT_SetPage($hash,0,$newdata);
$ret .= OWXCOUNT_GetPage($hash,0); $ret = OWXCOUNT_GetPage($hash,0,0);
$ret .= OWXCOUNT_SetPage($hash,0,$olddata); $ret = OWXCOUNT_SetPage($hash,0,$olddata);
##Use of uninitialized value in concatenation (.) or string at
##ERRORR /usr/share/fhem/FHEM/21_OWCOUNT.pm line 1100.
##Use of uninitialized value in concatenation (.) or string at
##/usr/share/fhem/FHEM/21_OWCOUNT.pm line 1103.
##Use of uninitialized value in concatenation (.) or string at
##/usr/share/fhem/FHEM/21_OWCOUNT.pm line 1104.
#-- OWFS interface #-- OWFS interface
}elsif( $interface eq "OWServer" ){ }elsif( $interface eq "OWServer" ){
$ret .= OWXCOUNT_GetPage($hash,0); $ret = OWXCOUNT_GetPage($hash,0,0);
$olddata = $hash->{owg_str}->[0]; $olddata = $hash->{owg_str}->[0];
$ret = OWFSCOUNT_SetPage($hash,0,$newdata); $ret = OWFSCOUNT_SetPage($hash,0,$newdata);
$ret .= OWFSCOUNT_GetPage($hash,0); $ret = OWFSCOUNT_GetPage($hash,0,0);
$ret .= OWFSCOUNT_SetPage($hash,0,$olddata); $ret = OWFSCOUNT_SetPage($hash,0,$olddata);
#-- Unknown interface #-- Unknown interface
}else{ }else{
return "OWCOUNT: InitializeDevice with wrong IODev type $interface"; return "OWCOUNT: InitializeDevice with wrong IODev type $interface";
@ -1193,29 +1188,15 @@ sub OWCOUNT_Set($@) {
#-- check syntax for setting memory page 0..13 or midnight A/B #-- check syntax for setting memory page 0..13 or midnight A/B
my $nomemory = defined($attr{$name}{"nomemory"}) ? $attr{$name}{"nomemory"} : 0; my $nomemory = defined($attr{$name}{"nomemory"}) ? $attr{$name}{"nomemory"} : 0;
if( ($key eq "memory") || ($key eq "midnight") ){ if( $key eq "memory" ){
if( $key eq "memory" ){ return "OWCOUNT: Memory usage disabled"
return "OWCOUNT: Memory usage disabled" if( $nomemory==1 );
if( $nomemory==1 ); return "OWCOUNT: Set needs parameter when writing memory: <page>"
return "OWCOUNT: Set needs parameter when writing memory: <page>" if( int(@a)<2 );
if( int(@a)<2 ); $page=int($a[2]);
$page=int($a[2]); if( ($page<0) || ($page>13) ){
if( ($page<0) || ($page>13) ){ return "OWXCOUNT: Wrong memory page write attempted";
return "OWXCOUNT: Wrong memory page write attempted";
}
}else{
return "OWCOUNT: Set needs parameter when writing midnight: <channel>"
if( int(@a)<2 );
#-- find out which channel we have
if( ($a[2] eq $owg_channel[0]) || ($a[2] eq "A") ){
$page=14;
}elsif( ($a[2] eq $owg_channel[1]) || ($a[2] eq "B") ){
$page=15;
} else {
return "OWCOUNT: Invalid midnight counter address, must be A, B or defined channel name"
}
} }
$data=$a[3]; $data=$a[3];
for( my $i=4;$i<int(@a);$i++){ for( my $i=4;$i<int(@a);$i++){
$data.=" ".$a[$i]; $data.=" ".$a[$i];
@ -1229,17 +1210,30 @@ sub OWCOUNT_Set($@) {
} }
} }
$ret = OWCOUNT_SetPage($hash,$page,$data); $ret = OWCOUNT_SetPage($hash,$page,$data);
}
#-- process results if( $key eq "midnight" ){
if( defined($ret) ){ return "OWCOUNT: Set needs parameter when writing midnight: <channel>"
return "OWCOUNT: Could not set device $name, reason: ".$ret; if( int(@a)<2 );
#-- find out which channel we have
if( ($a[2] eq $owg_channel[0]) || ($a[2] eq "A") ){
$page=14;
}elsif( ($a[2] eq $owg_channel[1]) || ($a[2] eq "B") ){
$page=15;
} else {
return "OWCOUNT: Invalid midnight counter address, must be A, B or defined channel name"
} }
my ($sec, $min, $hour, $day, $month, $year, $wday,$yday,$isdst) = localtime(time);
$data = sprintf("%4d-%02d-%02d midnight %7.2f",
$year+1900,$month+1,$day,$a[3]);
$ret = OWCOUNT_SetPage($hash,$page,$data);
}
#-- process results - we have to reread the device
if( defined($ret) && ($ret ne "") ){
return "OWCOUNT: Could not set device $name, reason: ".$ret;
} }
#-- process results - we have to reread the device
$hash->{PRESENT} = 1;
OWCOUNT_GetValues($hash); OWCOUNT_GetValues($hash);
Log 4, "OWCOUNT: Set $hash->{NAME} $key $value"; Log 5, "OWCOUNT: Set $hash->{NAME} $key $value";
} }
####################################################################################### #######################################################################################
@ -1276,7 +1270,7 @@ sub OWCOUNT_SetPage ($$$) {
} }
#-- process results #-- process results
if( defined($ret) ){ if( defined($ret) && ($ret ne "") ){
return "OWCOUNT: Could not set device $name, reason: ".$ret; return "OWCOUNT: Could not set device $name, reason: ".$ret;
} }
}else{ }else{
@ -1326,6 +1320,7 @@ sub OWCOUNT_recall($$) {
my ($hash,$filename) = @_; my ($hash,$filename) = @_;
my $name= $hash->{NAME}; my $name= $hash->{NAME};
my $mp = AttrVal("global", "modpath", "."); my $mp = AttrVal("global", "modpath", ".");
my $ret = open(OWXFILE, "< $mp/FHEM/$filename" ); my $ret = open(OWXFILE, "< $mp/FHEM/$filename" );
if( $ret ){ if( $ret ){
@ -1334,7 +1329,7 @@ sub OWCOUNT_recall($$) {
return $line; return $line;
} }
Log 1, "OWCOUNT_recall: Cannot open $filename for reading!"; Log 1, "OWCOUNT_recall: Cannot open $filename for reading!";
return 0; return undef;;
} }
######################################################################################## ########################################################################################
@ -1364,11 +1359,13 @@ sub OWCOUNT_Undef ($) {
# OWFSCOUNT_GetPage - Get page from device # OWFSCOUNT_GetPage - Get page from device
# #
# Parameter hash = hash of device addressed # Parameter hash = hash of device addressed
# page = page to be read
# final= 1 if FormatValues is to be called
# #
######################################################################################## ########################################################################################
sub OWFSCOUNT_GetPage($$) { sub OWFSCOUNT_GetPage($$$) {
my ($hash,$page) = @_; my ($hash,$page,$final) = @_;
#-- ID of the device #-- ID of the device
my $owx_add = substr($hash->{ROM_ID},0,15); my $owx_add = substr($hash->{ROM_ID},0,15);
@ -1377,6 +1374,9 @@ sub OWFSCOUNT_GetPage($$) {
my $master = $hash->{IODev}; my $master = $hash->{IODev};
my $name = $hash->{NAME}; my $name = $hash->{NAME};
#-- reset presence
$hash->{PRESENT} = 0;
my $vval; my $vval;
my $strval; my $strval;
@ -1406,15 +1406,14 @@ sub OWFSCOUNT_GetPage($$) {
}elsif( $page == 15) { }elsif( $page == 15) {
$vval = OWServer_Read($master,"/$owx_add/counters.B"); $vval = OWServer_Read($master,"/$owx_add/counters.B");
$strval = OWServer_Read($master,"/$owx_add/pages/page.15"); $strval = OWServer_Read($master,"/$owx_add/pages/page.15");
return "no return from OWServer" return "no return from OWServer"
if( (!defined($vval)) || (!defined($strval)) ); if( (!defined($vval)) || (!defined($strval)) );
return "empty return from OWServer" return "empty return from OWServer"
if( ($vval eq "") || ($strval eq "") ); if( ($vval eq "") || ($strval eq "") );
$hash->{owg_val}->[1] = $vval; $hash->{owg_val}->[1] = $vval;
$hash->{owg_str}->[15] = $strval; $hash->{owg_str}->[15] = $strval;
#-- parse float from midnight #-- parse float from midnight
$strval =~ s/[^\d\.]+//g; $strval =~ s/[^\d\.]+//g;
$strval = 0.0 if(!defined($strval) or $strval !~ /^\d+\.\d*$/); $strval = 0.0 if(!defined($strval) or $strval !~ /^\d+\.\d*$/);
@ -1422,17 +1421,18 @@ sub OWFSCOUNT_GetPage($$) {
$hash->{owg_midnight}->[1] = $strval; $hash->{owg_midnight}->[1] = $strval;
}else { }else {
$strval = OWServer_Read($master,"/$owx_add/pages/page.".$page); $strval = OWServer_Read($master,"/$owx_add/pages/page.".$page);
return "no return from OWServer" return "no return from OWServer"
if( !defined($strval) ); if( !defined($strval) );
return "empty return from OWServer" return "empty return from OWServer"
if( $strval eq "" ); if( $strval eq "" );
$hash->{owg_str}->[$page] = $strval; $hash->{owg_str}->[$page] = $strval;
} }
#-- and now from raw to formatted values #-- and now from raw to formatted values
my $value = OWCOUNT_FormatValues($hash); $hash->{PRESENT} = 1;
Log 5, $value; if($final==1){
my $value = OWCOUNT_FormatValues($hash);
Log 5, $value;
}
return undef; return undef;
} }
@ -1469,17 +1469,86 @@ sub OWFSCOUNT_SetPage($$$) {
# #
# Prefix = OWXCOUNT # Prefix = OWXCOUNT
# #
########################################################################################
#
# OWXCOUNT_BinValues - Process reading from one device - translate binary into raw
#
# Parameter hash = hash of device addressed
#
########################################################################################
sub OWXCOUNT_BinValues($$$$$$$$) {
my ($hash, $page, $success, $reset, $owx_dev, $data, $final, $res) = @_;
#-- unused are success, reset, data
return undef unless (defined $page and $page ne "convert");
my $name = $hash->{NAME};
my ($i,$j,$k,@data,$strval,$value);
my $change = 0;
#-- process results
@data=split(//,$res);
return "invalid data length, ".int(@data)." instead of 45 bytes in three steps"
if( int(@data) < 45);
#return "invalid data"
# if (ord($data[17])<=0);
Log 1,"invalid CRC"
if (OWX_CRC16(substr($res,0,43),$data[43],$data[44]) == 0);
#-- first 3 command, next 32 are memory
my $nomemory = defined($attr{$name}{"nomemory"}) ? $attr{$name}{"nomemory"} : 0;
if( $nomemory==0 ){
#-- memory part, treated as string
$strval=substr($res,3,32);
$hash->{owg_str}->[$page]=$strval;
}
#-- counter part
if( ($page == 14) || ($page == 15) ){
@data=split(//,substr($res,35));
if ( ($data[4] | $data[5] | $data[6] | $data[7]) ne "\x00" ){
#Log 1, "device $owx_dev returns invalid data ".ord($data[4])." ".ord($data[5])." ".ord($data[6])." ".ord($data[7]);
return "device $owx_dev returns invalid data";
}
#-- counter value
$value = (ord($data[3])<<24) + (ord($data[2])<<16) +(ord($data[1])<<8) + ord($data[0]);
$hash->{owg_val}->[$page-14] = $value;
#-- midnight value
if( $nomemory==0 ){
#-- new format
if ($strval =~ /^\d\d\d\d-\d\d-\d\d.*/){
@data=split(' ',$strval);
$strval = $data[2];
}
#-- parse float from midnight
$strval =~ s/[^\d\.]+//g;
$strval = 0.0 if(!defined($strval) or $strval !~ /^\d+\.\d*$/);
$strval = int($strval*100)/100;
$hash->{owg_midnight}->[$page-14] = $strval;
}
}
#-- and now from raw to formatted values
$hash->{PRESENT} = 1;
if( $final==1) {
my $value = OWCOUNT_FormatValues($hash);
Log 5, $value;
}
return undef;
}
######################################################################################## ########################################################################################
# #
# OWXCOUNT_GetPage - Get one memory page + counter from device # OWXCOUNT_GetPage - Get one memory page + counter from device
# #
# Parameter hash = hash of device addressed # Parameter hash = hash of device addressed
# page = 0..15 # page = 0..15
# final= 1 if FormatValues is to be called
# #
######################################################################################## ########################################################################################
sub OWXCOUNT_GetPage($$) { sub OWXCOUNT_GetPage($$$) {
my ($hash,$page) = @_; my ($hash,$page,$final) = @_;
my ($select, $res, $res2, $res3, @data); my ($select, $res, $res2, $res3, @data);
@ -1487,6 +1556,9 @@ sub OWXCOUNT_GetPage($$) {
my $owx_dev = $hash->{ROM_ID}; my $owx_dev = $hash->{ROM_ID};
my $master = $hash->{IODev}; my $master = $hash->{IODev};
#-- reset presence
$hash->{PRESENT} = 0;
my ($i,$j,$k); my ($i,$j,$k);
#=============== wrong value requested =============================== #=============== wrong value requested ===============================
@ -1529,76 +1601,14 @@ sub OWXCOUNT_GetPage($$) {
} }
} }
#-- reset the bus (needed to stop receiving data ?) #-- reset the bus (needed to stop receiving data ?)
#OWX_Reset($master); OWX_Reset($master);
#-- for processing we need 45 bytes #-- for processing we need 45 bytes
OWXCOUNT_BinValues($hash,$page,undef,undef,$owx_dev,undef,undef,substr($res,9)); OWXCOUNT_BinValues($hash,$page,undef,undef,$owx_dev,undef,$final,substr($res,9))
if( length($res)==54 );
} }
return undef; return undef;
} }
########################################################################################
#
# OWXCOUNT_BinValues - Process reading from one device - translate binary into raw
#
# Parameter hash = hash of device addressed
#
########################################################################################
sub OWXCOUNT_BinValues($$$$$$$$) {
my ($hash, $page, $success, $reset, $owx_dev, $data, $numread, $res) = @_;
#-- unused are success, reset, data numread
return undef unless (defined $page and $page ne "convert");
my ($i,$j,$k,@data,$strval);
my $change = 0;
#-- process results
@data=split(//,$res);
return "invalid data length, ".int(@data)." instead of 45 bytes in three steps"
if( int(@data) < 45);
#return "invalid data"
# if (ord($data[17])<=0);
Log 1,"invalid CRC"
if (OWX_CRC16(substr($res,0,43),$data[43],$data[44]) == 0);
#-- first 3 command, next 32 are memory
#-- memory part, treated as string
$strval=substr($res,3,32);
$hash->{owg_str}->[$page]=$strval;
#-- counter part
if( ($page == 14) || ($page == 15) ){
@data=split(//,substr($res,35));
if ( ($data[4] | $data[5] | $data[6] | $data[7]) ne "\x00" ){
#Log 1, "device $owx_dev returns invalid data ".ord($data[4])." ".ord($data[5])." ".ord($data[6])." ".ord($data[7]);
return "device $owx_dev returns invalid data";
}
my $value = (ord($data[3])<<24) + (ord($data[2])<<16) +(ord($data[1])<<8) + ord($data[0]);
if( $page == 14) {
$hash->{owg_val}->[0] = $value;
#-- parse float from midnight
$strval =~ s/[^\d\.]+//g;
$strval = 0.0 if(!defined($strval) or $strval !~ /^\d+\.\d*$/);
$strval = int($strval*100)/100;
$hash->{owg_midnight}->[0] = $strval;
}elsif( $page == 15) {
$hash->{owg_val}->[1] = $value;
#-- parse float from midnight
$strval =~ s/[^\d\.]+//g;
$strval = 0.0 if(!defined($strval) or $strval !~ /^\d+\.\d*$/);
$strval = int($strval*100)/100;
$hash->{owg_midnight}->[1] = $strval;
}
}
#-- and now from raw to formatted values
my $value = OWCOUNT_FormatValues($hash);
Log 5, $value;
return undef;
}
######################################################################################## ########################################################################################
# #
# OWXCOUNT_SetPage - Set one memory page of device # OWXCOUNT_SetPage - Set one memory page of device

28
fhem/FHEM/21_OWID.pm
View File

@ -53,7 +53,7 @@ use strict;
use warnings; use warnings;
sub Log($$); sub Log($$);
my $owx_version="5.04"; my $owx_version="5.05";
#-- declare variables #-- declare variables
my %gets = ( my %gets = (
"present" => "", "present" => "",
@ -217,20 +217,18 @@ sub OWID_Attr(@) {
my $ret; my $ret;
if ( $do eq "set") { if ( $do eq "set") {
ARGUMENT_HANDLER: { #-- interval modified at runtime
#-- interval modified at runtime $key eq "interval" and do {
$key eq "interval" and do { #-- check value
#-- check value return "OWID: Set with short interval, must be > 1" if(int($value) < 1);
return "OWID: Set with short interval, must be > 1" if(int($value) < 1); #-- update timer
#-- update timer $hash->{INTERVAL} = $value;
$hash->{INTERVAL} = $value; if ($init_done) {
if ($init_done) { RemoveInternalTimer($hash);
RemoveInternalTimer($hash); InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWID_GetValues", $hash, 1);
InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWID_GetValues", $hash, 1); }
} last;
last; };
};
}
} }
return $ret; return $ret;
} }

38
fhem/FHEM/21_OWLCD.pm
View File

@ -57,12 +57,12 @@
######################################################################################## ########################################################################################
package main; package main;
use vars qw{%attr %defs}; use vars qw{%attr %defs %modules $readingFnAttributes $init_done};
use strict; use strict;
use warnings; use warnings;
sub Log($$); sub Log($$);
my $owx_version="3.23"; my $owx_version="3.34";
#-- controller may be HD44780 or KS0073 #-- controller may be HD44780 or KS0073
# these values have to be changed for different display # these values have to be changed for different display
# geometries or memory maps # geometries or memory maps
@ -118,11 +118,12 @@ sub OWLCD_Initialize ($) {
$hash->{UndefFn} = "OWLCD_Undef"; $hash->{UndefFn} = "OWLCD_Undef";
$hash->{GetFn} = "OWLCD_Get"; $hash->{GetFn} = "OWLCD_Get";
$hash->{SetFn} = "OWLCD_Set"; $hash->{SetFn} = "OWLCD_Set";
$hash->{AttrFn} = "OWLCD_Attr";
my $attlist = "IODev do_not_notify:0,1 showtime:0,1 loglevel:0,1,2,3,4,5 ". my $attlist = "IODev do_not_notify:0,1 showtime:0,1 loglevel:0,1,2,3,4,5 ".
""; "";
$hash->{AttrList} = $attlist; $hash->{AttrList} = $attlist;
#make sure OWX is loaded so OWX_CRC is available if running with OWServer #-- make sure OWX is loaded so OWX_CRC is available if running with OWServer
main::LoadModule("OWX"); main::LoadModule("OWX");
} }
@ -201,6 +202,33 @@ sub OWLCD_Define ($$) {
return undef; return undef;
} }
#######################################################################################
#
# OWLCD_Attr - Set one attribute value for device
#
# Parameter hash = hash of device addressed
# a = argument array
#
########################################################################################
sub OWLCD_Attr(@) {
my ($do,$name,$key,$value) = @_;
my $hash = $defs{$name};
my $ret;
# if ( $do eq "set") {
# ARGUMENT_HANDLER: {
# #-- empty so far
# };
#} elsif ( $do eq "del" ) {
# ARGUMENT_HANDLER: {
# #-- empty so far
# }
# }
return $ret;
}
######################################################################################## ########################################################################################
# #
# OWLCD_Get - Implements GetFn function # OWLCD_Get - Implements GetFn function
@ -669,10 +697,10 @@ sub OWXLCD_GetMemory($$) {
return "OWLCD: Device $owx_dev not accessible for reading in 2nd step"; return "OWLCD: Device $owx_dev not accessible for reading in 2nd step";
} }
#-- process results (10 byes or more have been sent) #-- process results (10 bytes or more have been sent)
$res2 = substr($res,11,16); $res2 = substr($res,11,16);
Log 1," Having received ".length($res)." bytes"; #Log 1," Having received ".length($res)." bytes";
return $res2; return $res2;
} }

53
fhem/FHEM/21_OWMULTI.pm
View File

@ -70,7 +70,7 @@ use strict;
use warnings; use warnings;
sub Log($$); sub Log($$);
my $owx_version="5.04"; my $owx_version="5.05";
#-- flexible channel name #-- flexible channel name
my $owg_channel; my $owg_channel;
@ -156,20 +156,18 @@ sub OWMULTI_Attr(@) {
my $ret; my $ret;
if ( $do eq "set") { if ( $do eq "set") {
ARGUMENT_HANDLER: { #-- interval modified at runtime
#-- interval modified at runtime $key eq "interval" and do {
$key eq "interval" and do { #-- check value
#-- check value return "OWMULTI: Set with short interval, must be > 1" if(int($value) < 1);
return "OWMULTI: Set with short interval, must be > 1" if(int($value) < 1); #-- update timer
#-- update timer $hash->{INTERVAL} = $value;
$hash->{INTERVAL} = $value; if ($init_done) {
if ($init_done) { RemoveInternalTimer($hash);
RemoveInternalTimer($hash); InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWMULTI_GetValues", $hash, 1);
InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWMULTI_GetValues", $hash, 1); }
} last;
last; };
};
}
} }
return $ret; return $ret;
} }
@ -254,9 +252,6 @@ sub OWMULTI_Define ($$) {
if( !defined($hash->{IODev}->{NAME}) || !defined($hash->{IODev}) ){ if( !defined($hash->{IODev}->{NAME}) || !defined($hash->{IODev}) ){
return "OWMULTI: Warning, no 1-Wire I/O device found for $name."; return "OWMULTI: Warning, no 1-Wire I/O device found for $name.";
} }
#if( $hash->{IODev}->{PRESENT} != 1 ){
# return "OWMULTI: Warning, 1-Wire I/O device ".$hash->{IODev}->{NAME}." not present for $name.";
#}
$main::modules{OWMULTI}{defptr}{$id} = $hash; $main::modules{OWMULTI}{defptr}{$id} = $hash;
#-- #--
readingsSingleUpdate($hash,"state","defined",1); readingsSingleUpdate($hash,"state","defined",1);
@ -458,9 +453,6 @@ sub OWMULTI_Get($@) {
return "$name.version => $owx_version"; return "$name.version => $owx_version";
} }
#-- reset presence
$hash->{PRESENT} = 0;
#-- for the other readings we need a new reading #-- for the other readings we need a new reading
#-- OWX interface #-- OWX interface
if( $interface eq "OWX" ){ if( $interface eq "OWX" ){
@ -479,7 +471,6 @@ sub OWMULTI_Get($@) {
if( defined($ret) ){ if( defined($ret) ){
return "OWMULTI: Could not get values from device $name, reason $ret"; return "OWMULTI: Could not get values from device $name, reason $ret";
} }
$hash->{PRESENT} = 1;
#-- return the special reading #-- return the special reading
if ($reading eq "reading") { if ($reading eq "reading") {
@ -509,7 +500,7 @@ sub OWMULTI_Get($@) {
# #
######################################################################################## ########################################################################################
sub OWMULTI_GetValues($@) { sub OWMULTI_GetValues($) {
my $hash = shift; my $hash = shift;
my $name = $hash->{NAME}; my $name = $hash->{NAME};
@ -524,8 +515,6 @@ sub OWMULTI_GetValues($@) {
RemoveInternalTimer($hash); RemoveInternalTimer($hash);
InternalTimer(time()+$hash->{INTERVAL}, "OWMULTI_GetValues", $hash, 1); InternalTimer(time()+$hash->{INTERVAL}, "OWMULTI_GetValues", $hash, 1);
#-- reset presence
$hash->{PRESENT} = 0;
#-- Get values according to interface type #-- Get values according to interface type
my $interface= $hash->{IODev}->{TYPE}; my $interface= $hash->{IODev}->{TYPE};
@ -546,7 +535,6 @@ sub OWMULTI_GetValues($@) {
if( defined($ret) ){ if( defined($ret) ){
return "OWMULTI: Could not get values from device $name, reason $ret"; return "OWMULTI: Could not get values from device $name, reason $ret";
} }
$hash->{PRESENT} = 1;
return undef; return undef;
} }
@ -642,7 +630,6 @@ sub OWMULTI_Set($@) {
} }
#-- process results - we have to reread the device #-- process results - we have to reread the device
$hash->{PRESENT} = 1;
OWMULTI_GetValues($hash); OWMULTI_GetValues($hash);
Log 4, "OWMULTI: Set $hash->{NAME} $key $value"; Log 4, "OWMULTI: Set $hash->{NAME} $key $value";
@ -691,6 +678,9 @@ sub OWFSMULTI_GetValues($) {
my $master = $hash->{IODev}; my $master = $hash->{IODev};
my $name = $hash->{NAME}; my $name = $hash->{NAME};
#-- reset presence
$hash->{PRESENT} = 0;
#-- get values - or should we rather get the uncached ones ? #-- get values - or should we rather get the uncached ones ?
$hash->{owg_val}->[0] = OWServer_Read($master,"/$owx_add/temperature"); $hash->{owg_val}->[0] = OWServer_Read($master,"/$owx_add/temperature");
$hash->{owg_val}->[1] = OWServer_Read($master,"/$owx_add/VDD"); $hash->{owg_val}->[1] = OWServer_Read($master,"/$owx_add/VDD");
@ -702,6 +692,7 @@ sub OWFSMULTI_GetValues($) {
if( ($hash->{owg_val}->[0] eq "") || ($hash->{owg_val}->[1] eq "") || ($hash->{owg_val}->[2] eq "") ); if( ($hash->{owg_val}->[0] eq "") || ($hash->{owg_val}->[1] eq "") || ($hash->{owg_val}->[2] eq "") );
#-- and now from raw to formatted values #-- and now from raw to formatted values
$hash->{PRESENT} = 1;
my $value = OWMULTI_FormatValues($hash); my $value = OWMULTI_FormatValues($hash);
Log 5, $value; Log 5, $value;
return undef; return undef;
@ -797,6 +788,7 @@ sub OWXMULTI_BinValues($$$$$$$$) {
$hash->{owg_val}->[2] = ($msb*256+ $lsb)/100; $hash->{owg_val}->[2] = ($msb*256+ $lsb)/100;
#-- and now from raw to formatted values #-- and now from raw to formatted values
$hash->{PRESENT} = 1;
my $value = OWMULTI_FormatValues($hash); my $value = OWMULTI_FormatValues($hash);
Log 5, $value; Log 5, $value;
}; };
@ -808,12 +800,13 @@ sub OWXMULTI_BinValues($$$$$$$$) {
# OWXMULTI_GetValues - Get reading from one device # OWXMULTI_GetValues - Get reading from one device
# #
# Parameter hash = hash of device addressed # Parameter hash = hash of device addressed
# final= 1 if FormatValues is to be called
# #
######################################################################################## ########################################################################################
sub OWXMULTI_GetValues($) { sub OWXMULTI_GetValues($$) {
my ($hash) = @_; my ($hash,$final) = @_;
my ($i,$j,$k,$res,$res2); my ($i,$j,$k,$res,$res2);
@ -822,6 +815,8 @@ sub OWXMULTI_GetValues($) {
#-- hash of the busmaster #-- hash of the busmaster
my $master = $hash->{IODev}; my $master = $hash->{IODev};
#-- reset presence
$hash->{PRESENT} = 0;
#------------------------------------------------------------------------------------ #------------------------------------------------------------------------------------
#-- switch the device to current measurement off, VDD only #-- switch the device to current measurement off, VDD only
#-- issue the match ROM command \x55 and the write scratchpad command #-- issue the match ROM command \x55 and the write scratchpad command

52
fhem/FHEM/21_OWSWITCH.pm
View File

@ -76,7 +76,7 @@ use strict;
use warnings; use warnings;
sub Log($$); sub Log($$);
my $owx_version="5.04"; my $owx_version="5.05";
#-- fixed raw channel name, flexible channel name #-- fixed raw channel name, flexible channel name
my @owg_fixed = ("A","B","C","D","E","F","G","H"); my @owg_fixed = ("A","B","C","D","E","F","G","H");
my @owg_channel = ("A","B","C","D","E","F","G","H"); my @owg_channel = ("A","B","C","D","E","F","G","H");
@ -248,9 +248,7 @@ sub OWSWITCH_Define ($$) {
if( !defined($hash->{IODev}->{NAME}) || !defined($hash->{IODev}) ){ if( !defined($hash->{IODev}->{NAME}) || !defined($hash->{IODev}) ){
return "OWSWITCH: Warning, no 1-Wire I/O device found for $name."; return "OWSWITCH: Warning, no 1-Wire I/O device found for $name.";
} }
#if( $hash->{IODev}->{PRESENT} != 1 ){
# return "OWSWITCH: Warning, 1-Wire I/O device ".$hash->{IODev}->{NAME}." not present for $name.";
#}
$main::modules{OWSWITCH}{defptr}{$id} = $hash; $main::modules{OWSWITCH}{defptr}{$id} = $hash;
#-- #--
readingsSingleUpdate($hash,"state","defined",1); readingsSingleUpdate($hash,"state","defined",1);
@ -280,20 +278,18 @@ sub OWSWITCH_Attr(@) {
my $ret; my $ret;
if ( $do eq "set") { if ( $do eq "set") {
ARGUMENT_HANDLER: { #-- interval modified at runtime
#-- interval modified at runtime $key eq "interval" and do {
$key eq "interval" and do { #-- check value
#-- check value return "OWSWITCH: Set with short interval, must be > 1" if(int($value) < 1);
return "OWSWITCH: Set with short interval, must be > 1" if(int($value) < 1); #-- update timer
#-- update timer $hash->{INTERVAL} = $value;
$hash->{INTERVAL} = $value; if ($init_done) {
if ($init_done) { RemoveInternalTimer($hash);
RemoveInternalTimer($hash); InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWSWITCH_GetValues", $hash, 1);
InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWSWITCH_GetValues", $hash, 1); }
} last;
last; };
};
}
} }
return $ret; return $ret;
} }
@ -460,9 +456,6 @@ sub OWSWITCH_Get($@) {
return "$name.version => $owx_version"; return "$name.version => $owx_version";
} }
#-- reset presence
$hash->{PRESENT} = 0;
#-- get channel names #-- get channel names
OWSWITCH_ChannelNames($hash); OWSWITCH_ChannelNames($hash);
@ -495,7 +488,6 @@ sub OWSWITCH_Get($@) {
return "OWSWITCH: Get with wrong IODev type $interface"; return "OWSWITCH: Get with wrong IODev type $interface";
} }
#-- process results #-- process results
$hash->{PRESENT} = 1;
return $name.".".$a[2]." => ".$hash->{READINGS}{$owg_channel[$fnd]}{VAL}; return $name.".".$a[2]." => ".$hash->{READINGS}{$owg_channel[$fnd]}{VAL};
#-- get all states #-- get all states
@ -515,7 +507,6 @@ sub OWSWITCH_Get($@) {
if( defined($ret) ){ if( defined($ret) ){
return "OWSWITCH: Could not get values from device $name, reason $ret"; return "OWSWITCH: Could not get values from device $name, reason $ret";
} }
$hash->{PRESENT} = 1;
return "OWSWITCH: $name.$reading => ".$hash->{READINGS}{"state"}{VAL}; return "OWSWITCH: $name.$reading => ".$hash->{READINGS}{"state"}{VAL};
} }
} }
@ -544,9 +535,6 @@ sub OWSWITCH_GetValues($) {
RemoveInternalTimer($hash); RemoveInternalTimer($hash);
InternalTimer(time()+$hash->{INTERVAL}, "OWSWITCH_GetValues", $hash, 1); InternalTimer(time()+$hash->{INTERVAL}, "OWSWITCH_GetValues", $hash, 1);
#-- reset presence
$hash->{PRESENT} = 0;
#-- Get readings according to interface type #-- Get readings according to interface type
my $interface= $hash->{IODev}->{TYPE}; my $interface= $hash->{IODev}->{TYPE};
if( $interface eq "OWX" ){ if( $interface eq "OWX" ){
@ -571,7 +559,6 @@ sub OWSWITCH_GetValues($) {
Log 3, "OWSWITCH: Could not get values from device $name, reason $ret"; Log 3, "OWSWITCH: Could not get values from device $name, reason $ret";
return 1; return 1;
} }
$hash->{PRESENT} = 1;
return undef; return undef;
} }
@ -765,7 +752,6 @@ sub OWSWITCH_Set($@) {
} }
#-- process results - we have to reread the device #-- process results - we have to reread the device
$hash->{PRESENT} = 1;
OWSWITCH_GetValues($hash); OWSWITCH_GetValues($hash);
Log 4, "OWSWITCH: Set $hash->{NAME} $key $value"; Log 4, "OWSWITCH: Set $hash->{NAME} $key $value";
return undef; return undef;
@ -811,6 +797,9 @@ sub OWFSSWITCH_GetState($) {
my $master = $hash->{IODev}; my $master = $hash->{IODev};
my $name = $hash->{NAME}; my $name = $hash->{NAME};
#-- reset presence
$hash->{PRESENT} = 0;
#-- get values - or should we rather use the uncached ones ? #-- get values - or should we rather use the uncached ones ?
my $rel = OWServer_Read($master,"/$owx_add/sensed.ALL"); my $rel = OWServer_Read($master,"/$owx_add/sensed.ALL");
my $rex = OWServer_Read($master,"/$owx_add/PIO.ALL"); my $rex = OWServer_Read($master,"/$owx_add/PIO.ALL");
@ -856,6 +845,7 @@ sub OWFSSWITCH_GetState($) {
} }
#-- and now from raw to formatted values #-- and now from raw to formatted values
$hash->{PRESENT} = 1;
my $value = OWSWITCH_FormatValues($hash); my $value = OWSWITCH_FormatValues($hash);
Log 5, $value; Log 5, $value;
return undef; return undef;
@ -1057,7 +1047,8 @@ sub OWXSWITCH_BinValues($$$$$$$$) {
} }
#-- and now from raw to formatted values #-- and now from raw to formatted values
my $value = OWSWITCH_FormatValues($hash); $hash->{PRESENT} = 1;
$value = OWSWITCH_FormatValues($hash);
Log 5, $value; Log 5, $value;
return undef; return undef;
} }
@ -1106,6 +1097,9 @@ sub OWXSWITCH_GetState($) {
#-- hash of the busmaster #-- hash of the busmaster
my $master = $hash->{IODev}; my $master = $hash->{IODev};
#-- reset presence
$hash->{PRESENT} = 0;
my ($i,$j,$k); my ($i,$j,$k);
#-- family = 12 => DS2406 #-- family = 12 => DS2406