FHEM/fhem-mirror
2
0
Fork 0
mirror of https://github.com/fhem/fhem-mirror.git synced 2025-04-09 01:34:19 +00:00
Code Issues Releases Wiki Activity
fhem-mirror/fhem/contrib/1-Wire/21_OWAD.pm
pahenning 716f7befec Kleiner Änderungen, neues Modul 21_OWAD.pm 
git-svn-id: https://svn.fhem.de/fhem/trunk@1306 2b470e98-0d58-463d-a4d8-8e2adae1ed80
2012-02-29 12:14:25 +00:00

1029 lines
33 KiB
Perl
Raw Blame History

########################################################################################
#
# OWAD.pm
#
# FHEM module to commmunicate with 1-Wire A/D converters
#
# Attention: This module may communicate with the OWX module
# currently not with the 1-Wire File System OWFS,
#
# Prefixes for subroutines of this module:
# OW = General 1-Wire routines Peter Henning)
# OWX = 1-Wire bus master interface (Peter Henning)
# OWFS = 1-Wire file system (??)
#
# Prof. Dr. Peter A. Henning, 2012
#
# Version 1.02 - February 29, 2012
#
# Setup bus device in fhem.cfg as
# define <name> OWAD [<model>] <ROM_ID> [interval]
#
# where <name> may be replaced by any name string
#
# <model> is a 1-Wire device type. If omitted, we assume this to be an
# DS2450 A/D converter
# <ROM_ID> is a 12 character (6 byte) 1-Wire ROM ID
# without Family ID, e.g. A2D90D000800
# [interval] is an optional query interval in seconds
#
# Additional attributes are defined in fhem.cfg as
#
# attr <name> offset <float> = a offset added to the v1erature reading
#
########################################################################################
#
# 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;
#-- Prototypes to make komodo happy
use vars qw{%attr %defs};
use strict;
use warnings;
sub Log($$);
#-- declare variables
my $ownet;
my %gets = ();
my %sets = ();
my %updates = ();
##-- value globals
my @owg_status;
#-- channel name - fixed for now
my @owg_channel = ("A","B","C","D");
#-- channel values
my @owg_val;
#-- channel mode
my @owg_mode = ("input","input","input","input");
#-- resolution in bit - fixed for now
my @owg_resoln = (16,16,16,16);
#-- bare range in mV - fixed for now
my @owg_range = (5100,5100,5100,5100);
#-- alarm status 0 = disabled, 1 = enabled, but not present, 2 = alarmed
my @owg_alarmlow = (0,0,1,1);
my @owg_alarmhigh = (0,1,0,1);
#-- alarm values
my @owg_low = (0.0,0.0,0.0,0.0);
my @owg_high = (5.0,5.0,5.0,5.0);
%gets = (
"present" => "",
"interval" => "",
"reading" => "",
"alarm" => "",
"status" => "",
);
%sets = (
"interval" => "",
"Alow" => "",
"Ahigh" => "",
"Blow" => "",
"Bhigh" => "",
"Clow" => "",
"Chigh" => "",
"Dlow" => "",
"Dhigh" => ""
);
%updates = (
"present" => "",
"reading" => "",
"alarm" => "",
"status" => ""
);
########################################################################################
#
# The following subroutines are independent of the bus interface
#
# Prefix = OWAD
#
########################################################################################
#
# OWAD_Initialize
#
# Parameter hash = hash of device addressed
#
########################################################################################
sub OWAD_Initialize ($) {
my ($hash) = @_;
$hash->{DefFn} = "OWAD_Define";
$hash->{UndefFn} = "OWAD_Undef";
$hash->{GetFn} = "OWAD_Get";
$hash->{SetFn} = "OWAD_Set";
#Xoffset = a v(oltage) offset added to the reading
#Xfactor = a v(oltage) factor multiplied with (reading+offset)
#Xscale = a unit of measure
$hash->{AttrList}= "IODev do_not_notify:0,1 showtime:0,1 model:DS2450 loglevel:0,1,2,3,4,5 ".
"Aoffset Afactor Ascale Boffset Bfactor Bscale ".
"Coffset Cfactor Cscale Doffset Dfactor Dscale ";
}
#########################################################################################
#
# OWAD_Define - Implements DefFn function
#
# Parameter hash = hash of device addressed, def = definition string
#
#########################################################################################
sub OWAD_Define ($$) {
my ($hash, $def) = @_;
# define <name> OWAD [<model>] <id> [interval] [alarminterval]
# e.g.: define flow OWAD 525715020000 300
my @a = split("[ \t][ \t]*", $def);
my ($name,$model,$id,$interval,$alarminterval,$scale,$ret);
#-- default
$name = $a[0];
$interval = 30;
$scale = "";
$ret = "";
#-- check syntax
return "OWAD: Wrong syntax, must be define <name> OWAD [<model>] <id> [interval]"
if(int(@a) < 2 || int(@a) > 5);
#-- check if this is an old style definition, e.g. <model> is missing
my $a2 = lc($a[2]);
my $a3 = defined($a[3]) ? lc($a[3]) : "";
if( $a2 =~ m/^[0-9|a-f]{12}$/ ) {
$model = "DS2450";
$id = $a[2];
if(int(@a)>=4) { $interval = $a[3]; }
} elsif( $a3 =~ m/^[0-9|a-f]{12}$/ ) {
$model = $a[2];
return "OWAD: Wrong 1-Wire device model $model"
if( $model ne "DS2450");
$id = $a[3];
} else {
return "OWAD: $a[0] ID $a[2] invalid, specify a 12 digit value";
}
#-- 1-Wire ROM identifier in the form "FF.XXXXXXXXXXXX.YY"
# YY must be determined from id
my $crc = sprintf("%02x",OWX_CRC("20.".$id."00"));
#-- Define device internals
$hash->{INTERVAL} = $interval;
$hash->{ROM_ID} = "20.".$id.$crc;
$hash->{OW_ID} = $id;
$hash->{OW_FAMILY} = 20;
$hash->{PRESENT} = 0;
#-- Couple to I/O device
AssignIoPort($hash);
return "OWAD: No 1-Wire I/O device found for $name."
if(!defined($hash->{IODev}->{NAME}));
$modules{OWAD}{defptr}{$id} = $hash;
#-- Define several things
# Take channel names from $owg_channel
my $value2 = "";
for (my $i=0;$i<4;$i++){
#$owx_temp += $attr{$name}{offset} if ($attr{$name}{offset} );
#-- Initial readings values
$hash->{READINGS}{$owg_channel[$i]}{VAL} = 0.0;
$hash->{READINGS}{$owg_channel[$i]}{TIME} = "";
$hash->{READINGS}{$owg_channel[$i]."low"}{VAL} = 0.0;
$hash->{READINGS}{$owg_channel[$i]."low"}{TIME} = "";
$hash->{READINGS}{$owg_channel[$i]."high"}{VAL} = 0.0;
$hash->{READINGS}{$owg_channel[$i]."high"}{TIME} = "";
$value2 .= sprintf "%s: L- H- ",$owg_channel[$i];
}
$hash->{READINGS}{alarms}{VAL} = $value2;
$hash->{READINGS}{alarms}{TIME} = "";
$hash->{STATE} = "Defined";
Log 3, "OWAD: Device $name defined.";
my $interface= $hash->{IODev}->{TYPE};
#-- Initialization reading according to interface type
#-- OWX interface
if( $interface eq "OWX" ){
OWXAD_SetPage($hash,"alarm");
OWXAD_SetPage($hash,"status");
#-- OWFS interface
#}elsif( $interface eq "OWFS" ){
# $ret = OWFSAD_GetPage($hash,"reading");
#-- Unknown interface
}else{
return "OWAD: Define with wrong IODev type $interface";
}
#-- Start timer for updates
InternalTimer(time()+$hash->{INTERVAL}, "OWAD_GetValues", $hash, 0);
#-- InternalTimer blocks if init_done is not true
#my $oid = $init_done;
$hash->{STATE} = "Initialized";
return undef;
}
########################################################################################
#
# OWAD_Get - Implements GetFn function
#
# Parameter hash = hash of device addressed, a = argument array
#
########################################################################################
sub OWAD_Get($@) {
my ($hash, @a) = @_;
my $reading = $a[1];
my $name = $hash->{NAME};
my $model = $hash->{OW_MODEL};
my $value = undef;
my $ret = "";
#-- check argument
return "OWAD: Get with unknown argument $a[1], choose one of ".join(",", sort keys %gets)
if(!defined($gets{$a[1]}));
#-- check syntax
return "OWAD: Get argument is missing @a"
if(int(@a) != 2);
#-- get interval
if($a[1] eq "interval") {
$value = $hash->{INTERVAL};
return "$a[0] $reading => $value";
}
#-- get present
if($a[1] eq "present") {
$value = $hash->{PRESENT};
return "$a[0] $reading => $value";
}
my $interface= $hash->{IODev}->{TYPE};
#-- get reading according to interface type
if($a[1] eq "reading") {
#-- OWX interface
if( $interface eq "OWX" ){
$ret = OWXAD_GetPage($hash,"reading");
#-- OWFS interface
#}elsif( $interface eq "OWFS" ){
# $ret = OWFSAD_GetPage($hash,"reading");
#-- Unknown interface
}else{
return "OWAD: Get with wrong IODev type $interface";
}
#-- process results
my $tn = TimeNow();
$value = "";
for (my $i=0;$i<4;$i++){
#-- correct values for proper offset, factor
$owg_val[$i] += $attr{$name}{$owg_channel[$i]."offset"} if ($attr{$name}{$owg_channel[$i]."offset"} );
$owg_val[$i] *= $attr{$name}{$owg_channel[$i]."factor"} if ($attr{$name}{$owg_channel[$i]."factor"} );
#-- Test for alarm condition
#if( ($owg_v1 <= $owg_v2) | ($owg_v1 >= $owg_v3) ){
# $hash->{STATE} = "Alarmed";
#} else {
# $hash->{STATE} = "Normal";
#}
#-- put into READINGS
$hash->{READINGS}{$owg_channel[$i]}{VAL} = $owg_val[$i];
$hash->{READINGS}{$owg_channel[$i]}{TIME} = $tn;
$value .= sprintf "%s: %5.3f ",$owg_channel[$i],$owg_val[$i];
}
return "OWAD: $name.$reading => $value";
}
#-- get alarm values according to interface type
if($a[1] eq "alarm") {
#-- OWX interface
if( $interface eq "OWX" ){
$ret = OWXAD_GetPage($hash,"alarm");
#-- OWFS interface
#}elsif( $interface eq "OWFS" ){
# $ret = OWFSAD_GetPage($hash,"alarm");
#-- Unknown interface
}else{
return "OWAD: Get with wrong IODev type $interface";
}
#-- process results
my $tn = TimeNow();
$value = "";
for (my $i=0;$i<4;$i++){
#-- correct alarm values for proper offset, factor
$owg_low[$i] += $attr{$name}{$owg_channel[$i]."offset"} if ($attr{$name}{$owg_channel[$i]."offset"} );
$owg_low[$i] *= $attr{$name}{$owg_channel[$i]."factor"} if ($attr{$name}{$owg_channel[$i]."factor"} );
$owg_high[$i] += $attr{$name}{$owg_channel[$i]."offset"} if ($attr{$name}{$owg_channel[$i]."offset"} );
$owg_high[$i] *= $attr{$name}{$owg_channel[$i]."factor"} if ($attr{$name}{$owg_channel[$i]."factor"} );
#-- Test for alarm condition
#if( ($owg_v1 <= $owg_v2) | ($owg_v1 >= $owg_v3) ){
# $hash->{STATE} = "Alarmed";
#} else {
# $hash->{STATE} = "Normal";
#}
#-- put into READINGS
$hash->{READINGS}{$owg_channel[$i]."low"}{VAL} = $owg_low[$i];
$hash->{READINGS}{$owg_channel[$i]."low"}{TIME} = $tn;
$hash->{READINGS}{$owg_channel[$i]."high"}{VAL} = $owg_high[$i];
$hash->{READINGS}{$owg_channel[$i]."high"}{TIME} = $tn;
$value .= sprintf "%s:[%4.2f,%4.2f] ",$owg_channel[$i],$owg_low[$i],$owg_high[$i];
}
return "OWAD: $name.$reading => $value";
}
#-- get status values according to interface type
if($a[1] eq "status") {
#-- OWX interface
if( $interface eq "OWX" ){
$ret = OWXAD_GetPage($hash,"status");
#-- OWFS interface
#}elsif( $interface eq "OWFS" ){
# $ret = OWFSAD_GetPage($hash,"status");
#-- Unknown interface
}else{
return "OWAD: Get with wrong IODev type $interface";
}
#-- process results
my $tn = TimeNow();
$value = "";
my $value2 = "";
for (my $i=0;$i<4;$i++){
$value .= sprintf "%s: %s \n",$owg_channel[$i],$owg_status[$i];
$value2 .= sprintf "%s: L",$owg_channel[$i];
if( $owg_alarmlow[$i] == 0 ) {
$value2 .= "- ";
}elsif( $owg_alarmlow[$i] == 1 ) {
$value2 .= "+ ";
}else{
$value2 .= "* ";
}
$value2 .= sprintf " H";
if( $owg_alarmhigh[$i] == 0 ) {
$value2 .= "- ";
}elsif( $owg_alarmhigh[$i] == 1 ) {
$value2 .= "+ ";
}else{
$value2 .= "* ";
}
}
$hash->{READINGS}{alarms}{VAL} = $value2;
$hash->{READINGS}{alarms}{TIME} = $tn;
return "OWAD: $name.$reading => \n$value";
}
}
#######################################################################################
#
# OWAD_GetValues - Updates the reading from one device
#
# Parameter hash = hash of device addressed
#
########################################################################################
sub OWAD_GetValues($@) {
my $hash = shift;
my $name = $hash->{NAME};
my $model = $hash->{OW_MODEL};
my $value = "";
my $ret = "";
#-- define warnings
my $warn = "none";
$hash->{ALARM} = "0";
#-- restart timer for updates
RemoveInternalTimer($hash);
InternalTimer(time()+$hash->{INTERVAL}, "OWAD_GetValues", $hash, 1);
#-- Get readings, alarms and stati according to interface type
my $interface= $hash->{IODev}->{TYPE};
if( $interface eq "OWX" ){
OWXAD_GetPage($hash,"reading");
OWXAD_GetPage($hash,"alarm");
OWXAD_GetPage($hash,"status");
#}elsif( $interface eq "OWFS" ){
# $ret = OWFSAD_GetValues($hash);
}else{
return "OWAD: GetValues with wrong IODev type $interface";
}
#-- process results
my $tn = TimeNow();
$value = "";
my $value2 ="";
for (my $i=0;$i<4;$i++){
#-- correct values for proper offset, factor
$owg_val[$i] += $attr{$name}{$owg_channel[$i]."offset"} if ($attr{$name}{$owg_channel[$i]."offset"} );
$owg_val[$i] *= $attr{$name}{$owg_channel[$i]."factor"} if ($attr{$name}{$owg_channel[$i]."factor"} );
#-- correct alarm values for proper offset, factor
$owg_low[$i] += $attr{$name}{$owg_channel[$i]."offset"} if ($attr{$name}{$owg_channel[$i]."offset"} );
$owg_low[$i] *= $attr{$name}{$owg_channel[$i]."factor"} if ($attr{$name}{$owg_channel[$i]."factor"} );
$owg_high[$i] += $attr{$name}{$owg_channel[$i]."offset"} if ($attr{$name}{$owg_channel[$i]."offset"} );
$owg_high[$i] *= $attr{$name}{$owg_channel[$i]."factor"} if ($attr{$name}{$owg_channel[$i]."factor"} );
#-- Test for alarm condition
#if( ($owg_v1 <= $owg_v2) | ($owg_v1 >= $owg_v3) ){
# $hash->{STATE} = "Alarmed";
#} else {
# $hash->{STATE} = "Normal";
#}
#-- put into READINGS
$hash->{READINGS}{$owg_channel[$i]}{VAL} = $owg_val[$i];
$hash->{READINGS}{$owg_channel[$i]}{TIME} = $tn;
$hash->{READINGS}{$owg_channel[$i]."low"}{VAL} = $owg_low[$i];
$hash->{READINGS}{$owg_channel[$i]."low"}{TIME} = $tn;
$hash->{READINGS}{$owg_channel[$i]."high"}{VAL} = $owg_high[$i];
$hash->{READINGS}{$owg_channel[$i]."high"}{TIME} = $tn;
$value .= sprintf "%s: %5.3f ",$owg_channel[$i],$owg_val[$i];
$value2 .= sprintf "%s: L",$owg_channel[$i];
if( $owg_alarmlow[$i] == 0 ) {
$value2 .= "- ";
}elsif( $owg_alarmlow[$i] == 1 ) {
$value2 .= "+ ";
}else{
$value2 .= "* ";
}
$value2 .= sprintf " H";
if( $owg_alarmhigh[$i] == 0 ) {
$value2 .= "- ";
}elsif( $owg_alarmhigh[$i] == 1 ) {
$value2 .= "+ ";
}else{
$value2 .= "* ";
}
}
$hash->{READINGS}{alarms}{VAL} = $value2;
$hash->{READINGS}{alarms}{TIME} = $tn;
#--logging
Log 5, $value;
$hash->{CHANGED}[0] = $value;
DoTrigger($name, undef);
return undef;
}
#######################################################################################
#
# OWAD_Set - Set one value for device
#
# Parameter hash = hash of device addressed
# a = argument string
#
########################################################################################
sub OWAD_Set($@) {
my ($hash, @a) = @_;
my $key = $a[1];
my $value = $a[2];
my $ret = undef;
my $channel = undef;
my $channo = undef;
my $condx;
my $name = $hash->{NAME};
my $model = $hash->{OW_MODEL};
#-- for the selector: which values are possible
return join(" ", sort keys %sets) if(@a == 2);
#-- check syntax
return "OWAD: Set needs one parameter"
if(int(@a) != 3);
#-- check argument
return "OWAD: Set with unknown argument $a[1], choose one of ".join(",", sort keys %sets)
if(!defined($sets{$a[1]}));
#-- set new timer interval
if($key eq "interval") {
# check value
return "OWAD: Set with too short time value, interval must be > 10"
if(int($value) < 10);
# update timer
$hash->{INTERVAL} = $value;
RemoveInternalTimer($hash);
InternalTimer(gettimeofday()+$hash->{INTERVAL}, "OWAD_GetValues", $hash, 1);
return undef;
}
#-- set other values depending on interface type
my $interface= $hash->{IODev}->{TYPE};
Log 4, "OWTEMP: Set $hash->{NAME} $key $value";
#-- find out which channel we have
$channel=$key;
if( $channel =~ s/(.*)(low|high)/$channel=$1/se ) {
for (my $i=0;$i<4;$i++){
if( $channel eq $owg_channel[$i] ){
$channo = $i;
last;
}
}
}
#-- check alarm values
if( $key =~ m/(.*)(low|high)/ ) {
#-- find upper and lower boundaries for given offset/factor
my $mmin = 0.0;
$mmin /= $attr{$name}{$owg_channel[$channo]."factor"} if ($attr{$name}{$owg_channel[$channo]."factor"} );
$mmin -= $attr{$name}{$owg_channel[$channo]."offset"} if ($attr{$name}{$owg_channel[$channo]."offset"} );
my $mmax = $owg_range[$channo]/1000;
$mmax /= $attr{$name}{$owg_channel[$channo]."factor"} if ($attr{$name}{$owg_channel[$channo]."factor"} );
$mmax -= $attr{$name}{$owg_channel[$channo]."offset"} if ($attr{$name}{$owg_channel[$channo]."offset"} );
return sprintf("OWAD: Set with wrong value $value for $key, range is [%3.1f,%3.1f]",$mmin,$mmax)
if($value < $mmin || $value > $mmax);
#-- set alarm value in the device
if( $key =~ m/(.*)low/ ){
$owg_low[$channo] = $value;
$owg_low[$channo] /= $attr{$name}{$owg_channel[$channo]."factor"} if ($attr{$name}{$owg_channel[$channo]."factor"} );
$owg_low[$channo] -= $attr{$name}{$owg_channel[$channo]."offset"} if ($attr{$name}{$owg_channel[$channo]."offset"} );
#-- round to those numbers understood by the device and backward into the value;
$owg_low[$channo] = int($owg_low[$channo]*255000/$owg_range[$channo])*$owg_range[$channo]/255000;
$value = $owg_low[$channo];
$value += $attr{$name}{$owg_channel[$channo]."offset"} if ($attr{$name}{$owg_channel[$channo]."offset"} );
$value *= $attr{$name}{$owg_channel[$channo]."factor"} if ($attr{$name}{$owg_channel[$channo]."factor"} );
} else {
$owg_high[$channo] = $value;
$owg_high[$channo] /= $attr{$name}{$owg_channel[$channo]."factor"} if ($attr{$name}{$owg_channel[$channo]."factor"} );
$owg_high[$channo] -= $attr{$name}{$owg_channel[$channo]."offset"} if ($attr{$name}{$owg_channel[$channo]."offset"} );
#-- round to those numbers understood by the device and backward into the value;
$owg_high[$channo] = int($owg_high[$channo]*255000/$owg_range[$channo])*$owg_range[$channo]/255000;
$value = $owg_high[$channo];
$value += $attr{$name}{$owg_channel[$channo]."offset"} if ($attr{$name}{$owg_channel[$channo]."offset"} );
$value *= $attr{$name}{$owg_channel[$channo]."factor"} if ($attr{$name}{$owg_channel[$channo]."factor"} );
}
#-- OWX interface
if( $interface eq "OWX" ){
$ret = OWXAD_SetPage($hash,"alarm");
return $ret
if(defined($ret));
$ret = OWXAD_SetPage($hash,"status");
return $ret
if(defined($ret));
#-- OWFS interface
#}elsif( $interface eq "OWFS" ){
# $ret = OWFSAD_SetValues($hash,@a);
# return $ret
# if(defined($ret));
} else {
return "OWAD: Set with wrong IODev type $interface";
}
#-- process results
my $tn = TimeNow();
#-- set alarm value in the readings
if( $key =~ m/(.*)low/ ){
$hash->{READINGS}{$owg_channel[$channo]."low"}{VAL} = $value;
$hash->{READINGS}{$owg_channel[$channo]."low"}{TIME} = $tn;
#-- Test for alarm condition
if ( $owg_low[$channo] > $owg_val[$channo] ){
$owg_alarmlow[$channo] = 2
if($owg_alarmlow[$channo] == 1);
} elsif ($owg_alarmlow[$channo] == 2) {
$condx = 1;
$owg_alarmlow[$channo] = 1;
}
} else {
$hash->{READINGS}{$owg_channel[$channo]."high"}{VAL} = $value;
$hash->{READINGS}{$owg_channel[$channo]."high"}{TIME} = $tn;
#-- Test for new alarm condition
$condx = 0;
if ( $owg_high[$channo] < $owg_val[$channo] ){
$owg_alarmhigh[$channo] = 2
if($owg_alarmhigh[$channo] == 1);
} elsif($owg_alarmhigh[$channo] == 2) {
$condx = 1;
$owg_alarmhigh[$channo] = 1;
}
}
#-- set up a new alarm string for the status display
my $value2 = "";
for (my $i=0;$i<4;$i++){
$value2 .= sprintf "%s: L",$owg_channel[$i];
if( $owg_alarmlow[$i] == 0 ) {
$value2 .= "- ";
}elsif( $owg_alarmlow[$i] == 1 ) {
$value2 .= "+ ";
}else{
$value2 .= "* ";
}
$value2 .= sprintf " H";
if( $owg_alarmhigh[$i] == 0 ) {
$value2 .= "- ";
}elsif( $owg_alarmhigh[$i] == 1 ) {
$value2 .= "+ ";
}else{
$value2 .= "* ";
}
}
$hash->{READINGS}{alarms}{VAL} = $value2;
$hash->{READINGS}{alarms}{TIME} = $tn;
}
return undef;
}
########################################################################################
#
# OWAD_Undef - Implements UndefFn function
#
# Parameter hash = hash of device addressed
#
########################################################################################
sub OWAD_Undef ($) {
my ($hash) = @_;
delete($modules{OWTEMP}{defptr}{$hash->{OW_ID}});
RemoveInternalTimer($hash);
return undef;
}
########################################################################################
#
# The following subroutines in alphabetical order are only for a 1-Wire bus connected
# via OWFS
#
# Prefix = OWFSAD
#
########################################################################################
########################################################################################
#
# The following subroutines in alphabetical order are only for a 1-Wire bus connected
# directly to the FHEM server
#
# Prefix = OWXAD
#
########################################################################################
#
# OWXAD_GetPage - Get one memory page from device
#
# Parameter hash = hash of device addressed
# page = "reading", "alarm" or "status"
#
########################################################################################
sub OWXAD_GetPage($$) {
my ($hash,$page) = @_;
#-- For now, switch on conversion command
my $con=1;
my ($select, $res, $res2, $res3, @data);
#-- ID of the device
my $owx_dev = $hash->{ROM_ID};
my $owx_rnf = substr($owx_dev,3,12);
my $owx_f = substr($owx_dev,0,2);
#-- hash of the busmaster
my $master = $hash->{IODev};
my ($i,$j,$k);
#-- 8 byte 1-Wire device address
my @owx_ROM_ID =(0,0,0,0 ,0,0,0,0);
#-- from search string to byte id
my $devs=$owx_dev;
$devs=~s/\.//g;
for($i=0;$i<8;$i++){
$owx_ROM_ID[$i]=hex(substr($devs,2*$i,2));
}
#=============== get the voltage reading ===============================
if( $page eq "reading"){
#-- if the conversion has not been called before
if( $con==1 ){
OWX_Reset($master);
#-- issue the match ROM command \x55 and the start conversion command
$select = sprintf("\x55%c%c%c%c%c%c%c%c\x3C\x0F\x00\xFF\xFF",@owx_ROM_ID);
$res= OWX_Block($master,$select);
if( $res eq 0 ){
return "OWXAD: Device $owx_dev not accessible for conversion";
}
#-- conversion needs some 5 ms per channel
select(undef,undef,undef,0.02);
}
#-- issue the match ROM command \x55 and the read conversion page command
# \xAA\x00\x00 reading 8 data bytes and 2 CRC bytes
$select=sprintf("\x55%c%c%c%c%c%c%c%c\xAA\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
@owx_ROM_ID);
#=============== get the alarm reading ===============================
} elsif ( $page eq "alarm" ) {
#-- issue the match ROM command \x55 and the read alarm page command
# \xAA\x10\x00 reading 8 data bytes and 2 CRC bytes
$select=sprintf("\x55%c%c%c%c%c%c%c%c\xAA\x10\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
@owx_ROM_ID);
#=============== get the status reading ===============================
} elsif ( $page eq "status" ) {
#-- issue the match ROM command \x55 and the read status memory page command
# \xAA\x08\x00 reading 8 data bytes and 2 CRC bytes
$select=sprintf("\x55%c%c%c%c%c%c%c%c\xAA\x08\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
@owx_ROM_ID);
#=============== wrong value requested ===============================
} else {
return "OWXAD: Wrong memory page requested";
}
#-- reset the bus
OWX_Reset($master);
#-- read the data
$res=OWX_Block($master,$select);
if( $res eq 0 ){
return "OWXAD: Device $owx_dev not accessible in reading $page page";
}
#-- process results
@data=split(//,$res);
if ( (@data != 22) ){
return "OWXAD: Device $owx_dev returns invalid data";
}
#=============== get the voltage reading ===============================
if( $page eq "reading"){
for( $i=0;$i<4;$i++){
$owg_val[$i]= int((ord($data[12+2*$i])+256*ord($data[13+2*$i]))/((1<<$owg_resoln[$i])-1) * $owg_range[$i])/1000;
}
#=============== get the alarm reading ===============================
} elsif ( $page eq "alarm" ) {
for( $i=0;$i<4;$i++){
$owg_low[$i] = int(ord($data[12+2*$i])/255 * $owg_range[$i])/1000;
$owg_high[$i] = int(ord($data[13+2*$i])/255 * $owg_range[$i])/1000;
}
#=============== get the status reading ===============================
} elsif ( $page eq "status" ) {
my ($sb1,$sb2);
for( $i=0;$i<4;$i++){
$sb1 = ord($data[12+2*$i]);
$sb2 = ord($data[12+2*$i+1]);
#-- normal operation
if( $sb1 && 128) {
#-- put into globals
$owg_mode[$i] = "input";
$owg_resoln[$i] = ($sb1 & 15) + 1 ;
$owg_range[$i] = ($sb2 & 1) ? 5100 : 2550;
#-- low alarm disabled
if( ($sb2 & 4)==0 ){
$owg_alarmlow[$i] = 0;
}else {
#-- low alarm enabled and not set
if ( ($sb2 & 16)==0 ){
$owg_alarmlow[$i] = 1;
#-- low alarm enabled and set
}else{
$owg_alarmlow[$i] = 2;
}
}
#-- high alarm disabled
if( ($sb2 & 8)==0 ){
$owg_alarmhigh[$i] = 0;
}else {
#-- high alarm enabled and not set
if ( ($sb2 & 32)==0 ){
$owg_alarmhigh[$i] = 1;
#-- high alarm enabled and set
}else{
$owg_alarmhigh[$i] = 2;
}
}
#-- assemble status string
$owg_status[$i] = $owg_mode[$i].", ";
$owg_status[$i] .= "disabled ,"
if ( !($sb2 && 128) );
$owg_status[$i] .= sprintf "raw range %3.1f V, ",$owg_range[$i]/1000;
$owg_status[$i] .= sprintf "resolution %d bit, ",$owg_resoln[$i];
$owg_status[$i] .= sprintf "low alarm disabled, "
if( $owg_alarmlow[$i]==0 );
$owg_status[$i] .= sprintf "low alarm enabled, "
if( $owg_alarmlow[$i]==1 );
$owg_status[$i] .= sprintf "alarmed low, "
if( $owg_alarmlow[$i]==2 );
$owg_status[$i] .= sprintf "high alarm disabled"
if( $owg_alarmhigh[$i]==0 );
$owg_status[$i] .= sprintf "high alarm enabled"
if( $owg_alarmhigh[$i]==1 );
$owg_status[$i] .= sprintf "alarmed high"
if( $owg_alarmhigh[$i]==2 );
} else {
$owg_mode[$i] = "output";
#-- assemble status string
$owg_status[$i] = $owg_mode[$i].", ";
$owg_status[$i] .= ($sb1 & 64 ) ? "ON" : "OFF";
}
}
}
return undef
}
########################################################################################
#
# OWXAD_SetPage - Setup one memory page of device
#
# Parameter hash = hash of device addressed
# page = "alarm" or "status"
#
########################################################################################
sub OWXAD_SetPage($$) {
my ($hash,$page) = @_;
#-- For now, switch on conversion command
my $con=1;
my ($select, $res, $res2, $res3, @data);
#-- ID of the device
my $owx_dev = $hash->{ROM_ID};
my $owx_rnf = substr($owx_dev,3,12);
my $owx_f = substr($owx_dev,0,2);
#-- hash of the busmaster
my $master = $hash->{IODev};
my ($i,$j,$k);
#-- 8 byte 1-Wire device address
my @owx_ROM_ID =(0,0,0,0 ,0,0,0,0);
#-- from search string to byte id
my $devs=$owx_dev;
$devs=~s/\.//g;
for($i=0;$i<8;$i++){
$owx_ROM_ID[$i]=hex(substr($devs,2*$i,2));
}
#=============== set the alarm values ===============================
if ( $page eq "alarm" ) {
#-- issue the match ROM command \x55 and the set alarm page command
# \x55\x10\x00 reading 8 data bytes and 2 CRC bytes
$select=sprintf("\x55%c%c%c%c%c%c%c%c\x55\x10\x00",
@owx_ROM_ID);
for( $i=0;$i<4;$i++){
$select .= sprintf "%c\xFF\xFF\xFF",int($owg_low[$i]*255000/$owg_range[$i]);
$select .= sprintf "%c\xFF\xFF\xFF",int($owg_high[$i]*255000/$owg_range[$i]);
}
#=============== set the status ===============================
} elsif ( $page eq "status" ) {
my ($sb1,$sb2);
#-- issue the match ROM command \x55 and the set status memory page command
# \x55\x08\x00 reading 8 data bytes and 2 CRC bytes
$select=sprintf("\x55%c%c%c%c%c%c%c%c\x55\x08\x00",
@owx_ROM_ID);
for( $i=0;$i<4;$i++){
if( $owg_mode[$i] eq "input" ){
#-- resolution (TODO: check !)
$sb1 = $owg_resoln[$i]-1;
#-- alarm enabled
$sb2 = ( $owg_alarmlow[$i] > 0 ) ? 4 : 0;
$sb2 += ( $owg_alarmhigh[$i] > 0 ) ? 8 : 0;
#-- range
$sb2 |= 1
if( $owg_range[$i] > 2550 );
} else {
$sb1 = 128;
$sb2 = 0;
}
$select .= sprintf "%c\xFF\xFF\xFF",$sb1;
$select .= sprintf "%c\xFF\xFF\xFF",$sb2;
}
#=============== wrong value requested ===============================
} else {
return "OWXAD: Wrong memory page write attempt";
}
OWX_Reset($master);
$res=OWX_Block($master,$select);
#-- process results
if( $res eq 0 ){
return "OWXAD: Device $owx_dev not accessible for initialization";
}
return undef;
}
#######################################################################################
#
# OWXAD_SetValues - Implements SetFn function
#
# Parameter hash = hash of the device addressed here, a = argument array
#
########################################################################################
sub OWXAD_SetValues($@) {
my ($hash, @a) = @_;
my $name = $hash->{NAME};
#-- ID of the device
my $owx_dev = $hash->{ROM_ID};
my $owx_rnf = substr($owx_dev,3,12);
my $owx_f = substr($owx_dev,0,2);
#-- hash of the busmaster
my $master = $hash->{IODev};
my ($i,$j,$k);
#-- 8 byte 1-Wire device address
my @owx_ROM_ID =(0,0,0,0 ,0,0,0,0);
#-- from search string to byte id
my $devs=$owx_dev;
$devs=~s/\.//g;
for($i=0;$i<8;$i++){
$owx_ROM_ID[$i]=hex(substr($devs,2*$i,2));
}
# define vars
my $key = $a[1];
my $value = $a[2];
#-- get the old values
#$owg_v1 = $hash->{READINGS}{v1}{VAL};
#$owg_v2 = $hash->{READINGS}{v2}{VAL};
#$owg_v3 = $hash->{READINGS}{v3}{VAL};
#$owg_v4 = $hash->{READINGS}{v4}{VAL};
#-- put into 2's complement formed (signed byte)
#my $tlp = $owg_v2 < 0 ? 128 - $owg_v2 : $owg_v2;
#my $thp = $owg_v3 < 0 ? 128 - $owg_v3 : $owg_v3;
OWX_Reset($master);
#-- issue the match ROM command \x55 and the write scratchpad command \x4E,
# followed by the write EEPROM command \x48
#
# so far writing the EEPROM does not work properly.
# 1. \x48 directly appended to the write scratchpad command => command ok, no effect on EEPROM
# 2. \x48 appended to match ROM => command not ok.
# 3. \x48 sent by WriteBytePower after match ROM => command ok, no effect on EEPROM
#my $select=sprintf("\x55%c%c%c%c%c%c%c%c\x4E%c%c\x48",@owx_ROM_ID,$thp,$tlp);
#my $res=OWX_Block($master,$select);
#if( $res eq 0 ){
# return "OWXAD: Device $owx_dev not accessible";
#}
#-- issue the match ROM command \x55 and the copy scratchpad command \x48
#$select=sprintf("\x55%c%c%c%c%c%c%c%c",@owx_ROM_ID);
#$res=OWX_Block($hash,$select);
#$res=OWX_WriteBytePower($hash,"\x48");
#if( $res eq 0 ){
# Log 3, "OWXAD_SetTemp: Device $romid not accessible in the second step";
# return 0;
#}
DoTrigger($name, undef) if($init_done);
return undef;
}
1;
Reference in New Issue View Git Blame Copy Permalink