mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-03-12 22:56:34 +00:00
new TRX modules added
git-svn-id: https://svn.fhem.de/fhem/trunk@1283 2b470e98-0d58-463d-a4d8-8e2adae1ed80
This commit is contained in:
wherzig
parent
11e9841667
commit
b10dc6ae9a
@ -14,6 +14,7 @@
|
|||||||
- feature: FHEMWEB redirectCmds attribute added
|
- feature: FHEMWEB redirectCmds attribute added
|
||||||
- feature: CUL_TX minsecs attribute (by Arno)
|
- feature: CUL_TX minsecs attribute (by Arno)
|
||||||
- feature: webCmd in smallScreen added
|
- feature: webCmd in smallScreen added
|
||||||
|
- feature: TRX modules by Willi
|
||||||
|
|
||||||
- 2011-12-31 (5.2)
|
- 2011-12-31 (5.2)
|
||||||
- bugfix: applying smallscreen attributes to firefox/opera
|
- bugfix: applying smallscreen attributes to firefox/opera
|
||||||
|
|||||||
363
fhem/FHEM/45_TRX.pm
Executable file
363
fhem/FHEM/45_TRX.pm
Executable file
@ -0,0 +1,363 @@
|
|||||||
|
#################################################################################
|
||||||
|
# 45_TRX.pm
|
||||||
|
# Module for FHEM
|
||||||
|
#
|
||||||
|
# Tested with RFXtrx-Receiver (433.92MHz, USB)
|
||||||
|
# (see http://www.RFXCOM.com/).
|
||||||
|
# To use this module, you need to define an RFXTRX transceiver:
|
||||||
|
# define RFXTRX TRX /dev/ttyUSB0
|
||||||
|
#
|
||||||
|
# The module also has code to access a RFXtrx transceiver attached via LAN.
|
||||||
|
#
|
||||||
|
# To use it define the IP-Adresss and the Port:
|
||||||
|
# define RFXTRX TRX 192.168.169.111:10001
|
||||||
|
# optionally you may issue not to initialize the device (useful if you share an RFXtrx device with other programs)
|
||||||
|
# define RFXTRX TRX 192.168.169.111:10001 noinit
|
||||||
|
#
|
||||||
|
# The RFXtrx transceivers supports lots of protocols that may be implemented for FHEM
|
||||||
|
# writing the appropriate FHEM modules. See the
|
||||||
|
#
|
||||||
|
# Willi Herzig, 2012
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
#
|
||||||
|
#################################################################################
|
||||||
|
# derived from 00_CUL.pm
|
||||||
|
#
|
||||||
|
###########################
|
||||||
|
# $Id:
|
||||||
|
package main;
|
||||||
|
|
||||||
|
use strict;
|
||||||
|
use warnings;
|
||||||
|
use Time::HiRes qw(gettimeofday);
|
||||||
|
|
||||||
|
my $last_rmsg = "abcd";
|
||||||
|
my $last_time = 1;
|
||||||
|
|
||||||
|
sub TRX_Clear($);
|
||||||
|
sub TRX_Read($);
|
||||||
|
sub TRX_Ready($);
|
||||||
|
sub TRX_Parse($$$$);
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_Initialize($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
|
||||||
|
require "$attr{global}{modpath}/FHEM/DevIo.pm";
|
||||||
|
|
||||||
|
# Provider
|
||||||
|
$hash->{ReadFn} = "TRX_Read";
|
||||||
|
$hash->{WriteFn} = "TRX_Write";
|
||||||
|
$hash->{Clients} =
|
||||||
|
":TRX_WEATHER:TRX_SECURITY:TRX_LIGHT:";
|
||||||
|
my %mc = (
|
||||||
|
"1:TRX_WEATHER" => "^..(50|52|54|55|56).*",
|
||||||
|
"2:TRX_SECURITY" => "^..(20).*",
|
||||||
|
"3:TRX_LIGHT" => "^..(10).*",
|
||||||
|
"4:TRX_ELSE" => "^..(0|3|4|6|7|8|9).*",
|
||||||
|
);
|
||||||
|
$hash->{MatchList} = \%mc;
|
||||||
|
|
||||||
|
$hash->{ReadyFn} = "TRX_Ready";
|
||||||
|
|
||||||
|
# Normal devices
|
||||||
|
$hash->{DefFn} = "TRX_Define";
|
||||||
|
$hash->{UndefFn} = "TRX_Undef";
|
||||||
|
$hash->{GetFn} = "TRX_Get";
|
||||||
|
$hash->{SetFn} = "TRX_Set";
|
||||||
|
$hash->{StateFn} = "TRX_SetState";
|
||||||
|
$hash->{AttrList}= "do_not_notify:1,0 dummy:1,0 do_not_init:1:0 addvaltrigger:1:0 longids loglevel:0,1,2,3,4,5,6";
|
||||||
|
$hash->{ShutdownFn} = "TRX_Shutdown";
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_Define($$)
|
||||||
|
{
|
||||||
|
my ($hash, $def) = @_;
|
||||||
|
my @a = split("[ \t][ \t]*", $def);
|
||||||
|
|
||||||
|
return "wrong syntax: define <name> TRX devicename [noinit]"
|
||||||
|
if(@a != 3 && @a != 4);
|
||||||
|
|
||||||
|
DevIo_CloseDev($hash);
|
||||||
|
|
||||||
|
my $name = $a[0];
|
||||||
|
my $dev = $a[2];
|
||||||
|
my $opt = $a[3] if(@a == 4);;
|
||||||
|
|
||||||
|
if($dev eq "none") {
|
||||||
|
Log 1, "TRX: $name device is none, commands will be echoed only";
|
||||||
|
$attr{$name}{dummy} = 1;
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(defined($opt)) {
|
||||||
|
if($opt eq "noinit") {
|
||||||
|
Log 1, "TRX: $name no init is done";
|
||||||
|
$attr{$name}{do_not_init} = 1;
|
||||||
|
} else {
|
||||||
|
return "wrong syntax: define <name> TRX devicename [noinit]"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
$hash->{DeviceName} = $dev;
|
||||||
|
my $ret = DevIo_OpenDev($hash, 0, "TRX_DoInit");
|
||||||
|
return $ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
# Input is hexstring
|
||||||
|
sub
|
||||||
|
TRX_Write($$$)
|
||||||
|
{
|
||||||
|
my ($hash,$fn,$msg) = @_;
|
||||||
|
my $name = $hash->{NAME};
|
||||||
|
my $ll5 = GetLogLevel($name,5);
|
||||||
|
|
||||||
|
return if(!defined($fn));
|
||||||
|
|
||||||
|
my $bstring;
|
||||||
|
$bstring = "$fn$msg";
|
||||||
|
Log $ll5, "$hash->{NAME} sending $bstring";
|
||||||
|
|
||||||
|
DevIo_SimpleWrite($hash, $bstring, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_Undef($$)
|
||||||
|
{
|
||||||
|
my ($hash, $arg) = @_;
|
||||||
|
my $name = $hash->{NAME};
|
||||||
|
|
||||||
|
foreach my $d (sort keys %defs) {
|
||||||
|
if(defined($defs{$d}) &&
|
||||||
|
defined($defs{$d}{IODev}) &&
|
||||||
|
$defs{$d}{IODev} == $hash)
|
||||||
|
{
|
||||||
|
my $lev = ($reread_active ? 4 : 2);
|
||||||
|
Log GetLogLevel($name,$lev), "deleting port for $d";
|
||||||
|
delete $defs{$d}{IODev};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
DevIo_CloseDev($hash);
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_Shutdown($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_Set($@)
|
||||||
|
{
|
||||||
|
my ($hash, @a) = @_;
|
||||||
|
|
||||||
|
my $msg;
|
||||||
|
my $name=$a[0];
|
||||||
|
my $reading= $a[1];
|
||||||
|
$msg="$name => No Set function ($reading) implemented";
|
||||||
|
return $msg;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_Get($@)
|
||||||
|
{
|
||||||
|
my ($hash, @a) = @_;
|
||||||
|
|
||||||
|
my $msg;
|
||||||
|
my $name=$a[0];
|
||||||
|
my $reading= $a[1];
|
||||||
|
$msg="$name => No Get function ($reading) implemented";
|
||||||
|
Log 1,$msg;
|
||||||
|
return $msg;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_SetState($$$$)
|
||||||
|
{
|
||||||
|
my ($hash, $tim, $vt, $val) = @_;
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_Clear($)
|
||||||
|
{
|
||||||
|
my $hash = shift;
|
||||||
|
my $buf;
|
||||||
|
|
||||||
|
# clear buffer:
|
||||||
|
if($hash->{USBDev}) {
|
||||||
|
while ($hash->{USBDev}->lookfor()) {
|
||||||
|
$buf = DevIo_SimpleRead($hash);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if($hash->{TCPDev}) {
|
||||||
|
# TODO
|
||||||
|
return $buf;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_DoInit($)
|
||||||
|
{
|
||||||
|
my $hash = shift;
|
||||||
|
my $name = $hash->{NAME};
|
||||||
|
my $err;
|
||||||
|
my $msg = undef;
|
||||||
|
my $buf;
|
||||||
|
my $char = undef ;
|
||||||
|
|
||||||
|
|
||||||
|
# Reset
|
||||||
|
my $init = pack('H*', "0D00000000000000000000000000");
|
||||||
|
DevIo_SimpleWrite($hash, $init, 0);
|
||||||
|
DevIo_TimeoutRead($hash, 0.5);
|
||||||
|
|
||||||
|
TRX_Clear($hash);
|
||||||
|
|
||||||
|
if(defined($attr{$name}) && defined($attr{$name}{"do_not_init"})) {
|
||||||
|
Log 1, "TRX: defined with noinit. Do not send init string to device.";
|
||||||
|
$hash->{STATE} = "Initialized" if(!$hash->{STATE});
|
||||||
|
|
||||||
|
# Reset the counter
|
||||||
|
delete($hash->{XMIT_TIME});
|
||||||
|
delete($hash->{NR_CMD_LAST_H});
|
||||||
|
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#
|
||||||
|
# Get Status
|
||||||
|
$init = pack('H*', "0D00000102000000000000000000");
|
||||||
|
DevIo_SimpleWrite($hash, $init, 0);
|
||||||
|
$buf = DevIo_TimeoutRead($hash, 0.1);
|
||||||
|
|
||||||
|
if (! $buf) {
|
||||||
|
Log 1, "TRX: Initialization Error: No character read";
|
||||||
|
return "TRX: Initialization Error $name: no char read";
|
||||||
|
} elsif ($buf !~ m/^\x0d\x01\x00.........../) {
|
||||||
|
my $hexline = unpack('H*', $buf);
|
||||||
|
Log 1, "TRX: Initialization Error hexline='$hexline'";
|
||||||
|
return "TRX: Initialization Error %name expected char=0x2c, but char=$char received.";
|
||||||
|
} else {
|
||||||
|
Log 1, "TRX: Init OK";
|
||||||
|
$hash->{STATE} = "Initialized" if(!$hash->{STATE});
|
||||||
|
}
|
||||||
|
#
|
||||||
|
|
||||||
|
# Reset the counter
|
||||||
|
delete($hash->{XMIT_TIME});
|
||||||
|
delete($hash->{NR_CMD_LAST_H});
|
||||||
|
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
# called from the global loop, when the select for hash->{FD} reports data
|
||||||
|
sub
|
||||||
|
TRX_Read($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
my $name = $hash->{NAME};
|
||||||
|
|
||||||
|
my $char;
|
||||||
|
|
||||||
|
my $mybuf = DevIo_SimpleRead($hash);
|
||||||
|
|
||||||
|
if(!defined($mybuf) || length($mybuf) == 0) {
|
||||||
|
DevIo_Disconnected($hash);
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
my $TRX_data = $hash->{PARTIAL};
|
||||||
|
#Log 5, "TRX/RAW: $TRX_data/$mybuf";
|
||||||
|
$TRX_data .= $mybuf;
|
||||||
|
|
||||||
|
#my $hexline = unpack('H*', $TRX_data);
|
||||||
|
#Log 1, "TRX: TRX_Read '$hexline'";
|
||||||
|
|
||||||
|
# first char as byte represents number of bytes of the message
|
||||||
|
my $num_bytes = ord($TRX_data);
|
||||||
|
|
||||||
|
while(length($TRX_data) > $num_bytes) {
|
||||||
|
# the buffer contains at least the number of bytes we need
|
||||||
|
my $rmsg;
|
||||||
|
$rmsg = substr($TRX_data, 0, $num_bytes+1);
|
||||||
|
#my $hexline = unpack('H*', $rmsg);
|
||||||
|
#Log 1, "TRX_Read rmsg '$hexline'";
|
||||||
|
$TRX_data = substr($TRX_data, $num_bytes+1);;
|
||||||
|
#$hexline = unpack('H*', $TRX_data);
|
||||||
|
#Log 1, "TRX_Read TRX_data '$hexline'";
|
||||||
|
#
|
||||||
|
TRX_Parse($hash, $hash, $name, unpack('H*', $rmsg));
|
||||||
|
}
|
||||||
|
#Log 1, "TRX_Read END";
|
||||||
|
|
||||||
|
$hash->{PARTIAL} = $TRX_data;
|
||||||
|
}
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_Parse($$$$)
|
||||||
|
{
|
||||||
|
my ($hash, $iohash, $name, $rmsg) = @_;
|
||||||
|
|
||||||
|
#Log 1, "TRX_Parse1 '$rmsg'";
|
||||||
|
Log 5, "TRX_Parse1 '$rmsg'";
|
||||||
|
|
||||||
|
my %addvals;
|
||||||
|
# Parse only if message is different within 2 seconds
|
||||||
|
# (some Oregon sensors always sends the message twice, X10 security sensors even sends the message five times)
|
||||||
|
if (("$last_rmsg" ne "$rmsg") || (time() - $last_time) > 1) {
|
||||||
|
#Log 1, "TRX_Dispatch '$rmsg'";
|
||||||
|
%addvals = (RAWMSG => $rmsg);
|
||||||
|
Dispatch($hash, $rmsg, \%addvals);
|
||||||
|
$hash->{"${name}_MSGCNT"}++;
|
||||||
|
$hash->{"${name}_TIME"} = TimeNow();
|
||||||
|
$hash->{RAWMSG} = $rmsg;
|
||||||
|
} else {
|
||||||
|
#Log 1, "TRX_Dispatch '$rmsg' dup";
|
||||||
|
#Log 1, "<-duplicate->";
|
||||||
|
}
|
||||||
|
|
||||||
|
$last_rmsg = $rmsg;
|
||||||
|
$last_time = time();
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_Ready($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
return DevIo_OpenDev($hash, 1, "TRX_Ready")
|
||||||
|
if($hash->{STATE} eq "disconnected");
|
||||||
|
|
||||||
|
# This is relevant for windows/USB only
|
||||||
|
my $po = $hash->{USBDev};
|
||||||
|
my ($BlockingFlags, $InBytes, $OutBytes, $ErrorFlags) = $po->status;
|
||||||
|
return ($InBytes>0);
|
||||||
|
}
|
||||||
|
|
||||||
|
1;
|
||||||
102
fhem/FHEM/46_TRX_ELSE.pm
Executable file
102
fhem/FHEM/46_TRX_ELSE.pm
Executable file
@ -0,0 +1,102 @@
|
|||||||
|
#################################################################################
|
||||||
|
# 46_TRX_ELSE.pm
|
||||||
|
# Modul for FHEM for unkown RFXTRX messages
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
#
|
||||||
|
##################################
|
||||||
|
#
|
||||||
|
# values for "set global verbose"
|
||||||
|
# 4: log unknown protocols
|
||||||
|
# 5: log decoding hexlines for debugging
|
||||||
|
#
|
||||||
|
# $Id:
|
||||||
|
package main;
|
||||||
|
|
||||||
|
use strict;
|
||||||
|
use warnings;
|
||||||
|
use Switch;
|
||||||
|
|
||||||
|
my $time_old = 0;
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_ELSE_Initialize($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
$hash->{Match} = "^.*";
|
||||||
|
$hash->{DefFn} = "TRX_ELSE_Define";
|
||||||
|
$hash->{UndefFn} = "TRX_ELSE_Undef";
|
||||||
|
$hash->{ParseFn} = "TRX_ELSE_Parse";
|
||||||
|
$hash->{AttrList} = "IODev do_not_notify:1,0 loglevel:0,1,2,3,4,5,6";
|
||||||
|
Log 1, "TRX_ELSE: Initialize";
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_ELSE_Define($$)
|
||||||
|
{
|
||||||
|
my ($hash, $def) = @_;
|
||||||
|
my @a = split("[ \t][ \t]*", $def);
|
||||||
|
|
||||||
|
my $a = int(@a);
|
||||||
|
#print "a0 = $a[0]";
|
||||||
|
return "wrong syntax: define <name> TRX_ELSE code" if(int(@a) != 3);
|
||||||
|
|
||||||
|
my $name = $a[0];
|
||||||
|
my $code = $a[2];
|
||||||
|
|
||||||
|
$hash->{CODE} = $code;
|
||||||
|
#$modules{TRX_ELSE}{defptr}{$name} = $hash;
|
||||||
|
$modules{TRX_ELSE}{defptr}{$code} = $hash;
|
||||||
|
AssignIoPort($hash);
|
||||||
|
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_ELSE_Undef($$)
|
||||||
|
{
|
||||||
|
my ($hash, $name) = @_;
|
||||||
|
delete($modules{TRX_ELSE}{defptr}{$name});
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
my $DOT = q{_};
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_ELSE_Parse($$)
|
||||||
|
{
|
||||||
|
my ($hash, $msg) = @_;
|
||||||
|
|
||||||
|
my $time = time();
|
||||||
|
if ($time_old ==0) {
|
||||||
|
Log 5, "TRX_ELSE: decoding delay=0 hex=$msg";
|
||||||
|
} else {
|
||||||
|
my $time_diff = $time - $time_old ;
|
||||||
|
Log 5, "TRX_ELSE: decoding delay=$time_diff hex=$msg";
|
||||||
|
}
|
||||||
|
$time_old = $time;
|
||||||
|
|
||||||
|
# convert to binary
|
||||||
|
my $bin_msg = pack('H*', $msg);
|
||||||
|
#my $hexline = unpack('H*', $bin_msg);
|
||||||
|
#Log 1, "TRX_ELSE: 2 hex=$hexline";
|
||||||
|
|
||||||
|
# convert string to array of bytes. Skip length byte
|
||||||
|
my @rfxcom_data_array = ();
|
||||||
|
foreach (split(//, substr($bin_msg,1))) {
|
||||||
|
push (@rfxcom_data_array, ord($_) );
|
||||||
|
}
|
||||||
|
|
||||||
|
Log 0, "TRX_ELSE: hex=$msg";
|
||||||
|
|
||||||
|
return "Test";
|
||||||
|
}
|
||||||
|
|
||||||
|
1;
|
||||||
425
fhem/FHEM/46_TRX_LIGHT.pm
Executable file
425
fhem/FHEM/46_TRX_LIGHT.pm
Executable file
@ -0,0 +1,425 @@
|
|||||||
|
#################################################################################
|
||||||
|
# 46_TRX_LIGHT.pm
|
||||||
|
#
|
||||||
|
# Modul for FHEM for
|
||||||
|
# "X10" -> X10 lighting
|
||||||
|
# "ARC" -> ARC
|
||||||
|
# "AB400D" -> ELRO AB400D
|
||||||
|
# "WAVEMAN" -> Waveman
|
||||||
|
# "EMW200" -> Chacon EMW200
|
||||||
|
# "IMPULS" -> IMPULS
|
||||||
|
#
|
||||||
|
# - ms14a: motion sensor
|
||||||
|
# - x10: generic X10 sensor
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
#
|
||||||
|
##################################
|
||||||
|
#
|
||||||
|
# values for "set global verbose"
|
||||||
|
# 4: log unknown protocols
|
||||||
|
# 5: log decoding hexlines for debugging
|
||||||
|
#
|
||||||
|
# $Id: 43_TRX_LIGHT.pm 1098 2011-11-12 07:51:08Z rudolfkoenig $
|
||||||
|
package main;
|
||||||
|
|
||||||
|
use strict;
|
||||||
|
use warnings;
|
||||||
|
use Switch;
|
||||||
|
|
||||||
|
# Debug this module? YES = 1, NO = 0
|
||||||
|
my $TRX_LIGHT_debug = 0;
|
||||||
|
|
||||||
|
my $time_old = 0;
|
||||||
|
|
||||||
|
my $TRX_LIGHT_type_default = "ds10a";
|
||||||
|
my $TRX_LIGHT_X10_type_default = "x10";
|
||||||
|
|
||||||
|
my $DOT = q{_};
|
||||||
|
|
||||||
|
my %light_device_codes = ( # HEXSTRING => "NAME", "name of reading",
|
||||||
|
0x00 => [ "X10", "light" ],
|
||||||
|
0x01 => [ "ARC", "light" ],
|
||||||
|
0x02 => [ "AB400D", "light" ],
|
||||||
|
0x03 => [ "WAVEMAN", "light" ],
|
||||||
|
0x04 => [ "EMW200", "light"],
|
||||||
|
0x05 => [ "IMPULS", "light"],
|
||||||
|
);
|
||||||
|
|
||||||
|
my %light_device_commands = ( # HEXSTRING => commands
|
||||||
|
0x00 => [ "off", "on", "dim", "bright", "all_off", "all_on", ""],
|
||||||
|
0x01 => [ "off", "on", "", "", "all_off", "all_on", "chime"],
|
||||||
|
0x02 => [ "off", "on", "", "", "", "", ""],
|
||||||
|
0x03 => [ "off", "on", "", "", "", "", ""],
|
||||||
|
0x04 => [ "off", "on", "", "", "all_off", "all_on", ""],
|
||||||
|
0x05 => [ "off", "on", "", "", "", "", ""],
|
||||||
|
);
|
||||||
|
|
||||||
|
my %light_device_c2b; # DEVICE_TYPE->hash (reverse of light_device_codes)
|
||||||
|
|
||||||
|
# Get the binary value for a command
|
||||||
|
# return -1 if command not valid dor dev_type
|
||||||
|
sub TRX_LIGHT_cmd_to_binary {
|
||||||
|
my ($dev_type, $command) = @_;
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_LIGHT_Initialize($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
foreach my $k (keys %light_device_codes) {
|
||||||
|
$light_device_c2b{$light_device_codes{$k}->[0]} = $k;
|
||||||
|
}
|
||||||
|
|
||||||
|
#$hash->{Match} = "^\\).*"; # 0x29
|
||||||
|
$hash->{Match} = "^(\\ |\\)).*"; # 0x20 or 0x29
|
||||||
|
$hash->{SetFn} = "TRX_LIGHT_Set";
|
||||||
|
$hash->{DefFn} = "TRX_LIGHT_Define";
|
||||||
|
$hash->{UndefFn} = "TRX_LIGHT_Undef";
|
||||||
|
$hash->{ParseFn} = "TRX_LIGHT_Parse";
|
||||||
|
$hash->{AttrList} = "IODev do_not_notify:1,0 loglevel:0,1,2,3,4,5,6";
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_LIGHT_SetState($$$$)
|
||||||
|
{
|
||||||
|
my ($hash, $tim, $vt, $val) = @_;
|
||||||
|
|
||||||
|
$val = $1 if($val =~ m/^(.*) \d+$/);
|
||||||
|
# to be done. Just accept everything right now.
|
||||||
|
#return "Undefined value $val" if(!defined($fs20_c2b{$val}));
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
###################################
|
||||||
|
sub
|
||||||
|
TRX_LIGHT_Set($@)
|
||||||
|
{
|
||||||
|
my ($hash, @a) = @_;
|
||||||
|
my $ret = undef;
|
||||||
|
my $na = int(@a);
|
||||||
|
|
||||||
|
return "no set value specified" if($na < 2 || $na > 3);
|
||||||
|
|
||||||
|
# look for device_type
|
||||||
|
|
||||||
|
my $name = $a[0];
|
||||||
|
my $command = $a[1];
|
||||||
|
|
||||||
|
my $device_type = $hash->{TRX_LIGHT_type};
|
||||||
|
my $deviceid = $hash->{TRX_LIGHT_deviceid};
|
||||||
|
|
||||||
|
my $house;
|
||||||
|
my $unit;
|
||||||
|
if ($deviceid =~ /(.)(.*)/ ) {
|
||||||
|
$house = ord("$1");
|
||||||
|
$unit = $2;
|
||||||
|
} else {
|
||||||
|
Log 4,"TRX_LIGHT_Set wrong deviceid: name=$name device_type=$device_type, deviceid=$deviceid";
|
||||||
|
return "error set name=$name deviveid=$deviceid";
|
||||||
|
}
|
||||||
|
|
||||||
|
my $device_type_num = $light_device_c2b{$device_type};
|
||||||
|
if(!defined($device_type_num)) {
|
||||||
|
return "Unknown device_type, choose one of " .
|
||||||
|
join(" ", sort keys %light_device_c2b);
|
||||||
|
}
|
||||||
|
|
||||||
|
# Now check if the command is valid and retrieve the command id:
|
||||||
|
my $rec = $light_device_commands{$device_type_num};
|
||||||
|
my $i;
|
||||||
|
for ($i=0; $i <= $#$rec && ($rec->[$i] ne $command); $i++) { ;}
|
||||||
|
|
||||||
|
if($i > $#$rec) {
|
||||||
|
my $error = "Unknown command $command, choose one of " . join(" ", sort @$rec);
|
||||||
|
Log 4, $error;
|
||||||
|
return $error;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
my $seqnr = 0;
|
||||||
|
my $cmnd = $i;
|
||||||
|
|
||||||
|
my $hex_command = sprintf "0710%02x%02x%02x%02x%02x00", $device_type_num, $seqnr, $house, $unit, $cmnd;
|
||||||
|
Log 1,"TRX_LIGHT_Set name=$name device_type=$device_type, deviceid=$deviceid house=$house, unit=$unit command=$command" if ($TRX_LIGHT_debug == 1);
|
||||||
|
Log 1,"TRX_LIGHT_Set hexline=$hex_command" if ($TRX_LIGHT_debug == 1);
|
||||||
|
|
||||||
|
#IOWrite($hash, pack('H*', $hex_command));
|
||||||
|
IOWrite($hash, "", $hex_command);
|
||||||
|
|
||||||
|
my $tn = TimeNow();
|
||||||
|
$hash->{CHANGED}[0] = $command;
|
||||||
|
$hash->{STATE} = $command;
|
||||||
|
$hash->{READINGS}{state}{TIME} = $tn;
|
||||||
|
$hash->{READINGS}{state}{VAL} = $command;
|
||||||
|
|
||||||
|
return $ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_LIGHT_Define($$)
|
||||||
|
{
|
||||||
|
my ($hash, $def) = @_;
|
||||||
|
my @a = split("[ \t][ \t]*", $def);
|
||||||
|
|
||||||
|
my $a = int(@a);
|
||||||
|
|
||||||
|
if(int(@a) != 5 && int(@a) != 7) {
|
||||||
|
Log 1,"TRX_LIGHT wrong syntax '@a'. \nCorrect syntax is 'define <name> TRX_LIGHT <type> <deviceid> <devicelog> [<deviceid2> <devicelog2>]'";
|
||||||
|
return "wrong syntax: define <name> TRX_LIGHT <type> <deviceid> <devicelog> [<deviceid2> <devicelog2>]";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
my $name = $a[0];
|
||||||
|
|
||||||
|
my $type = lc($a[2]);
|
||||||
|
my $deviceid = $a[3];
|
||||||
|
my $devicelog = $a[4];
|
||||||
|
|
||||||
|
|
||||||
|
$type = uc($type);
|
||||||
|
|
||||||
|
my $device_name = "TRX".$DOT.$type.$DOT.$deviceid;
|
||||||
|
|
||||||
|
if ($type ne "X10" && $type ne "ARC" && $type ne "MS14A" && $type ne "AB400D" && $type ne "WAVEMAN" && $type ne "EMW200" && $type ne "IMPULS") {
|
||||||
|
Log 1,"RFX10SEC define: wrong type: $type";
|
||||||
|
return "RFX10SEC: wrong type: $type";
|
||||||
|
}
|
||||||
|
|
||||||
|
$hash->{TRX_LIGHT_deviceid} = $deviceid;
|
||||||
|
$hash->{TRX_LIGHT_devicelog} = $devicelog;
|
||||||
|
$hash->{TRX_LIGHT_type} = $type;
|
||||||
|
#$hash->{TRX_LIGHT_CODE} = $deviceid;
|
||||||
|
$modules{TRX_LIGHT}{defptr}{$device_name} = $hash;
|
||||||
|
|
||||||
|
|
||||||
|
if (int(@a) == 7) {
|
||||||
|
# there is a second deviceid:
|
||||||
|
#
|
||||||
|
my $deviceid2 = $a[5];
|
||||||
|
my $devicelog2 = $a[6];
|
||||||
|
|
||||||
|
my $device_name2 = "TRX".$DOT.$type.$DOT.$deviceid2;
|
||||||
|
|
||||||
|
$hash->{TRX_LIGHT_deviceid2} = $deviceid2;
|
||||||
|
$hash->{TRX_LIGHT_devicelog2} = $devicelog2;
|
||||||
|
#$hash->{TRX_LIGHT_CODE2} = $deviceid2;
|
||||||
|
$modules{TRX_LIGHT}{defptr2}{$device_name2} = $hash;
|
||||||
|
}
|
||||||
|
|
||||||
|
AssignIoPort($hash);
|
||||||
|
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_LIGHT_Undef($$)
|
||||||
|
{
|
||||||
|
my ($hash, $name) = @_;
|
||||||
|
delete($modules{TRX_LIGHT}{defptr}{$name});
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub TRX_LIGHT_parse_X10 {
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
my $error;
|
||||||
|
|
||||||
|
|
||||||
|
#my $device;
|
||||||
|
|
||||||
|
my $subtype = $bytes->[1];
|
||||||
|
my $dev_type;
|
||||||
|
my $dev_reading;
|
||||||
|
my $rest;
|
||||||
|
if (exists $light_device_codes{$subtype}) {
|
||||||
|
my $rec = $light_device_codes{$subtype};
|
||||||
|
($dev_type, $dev_reading) = @$rec;
|
||||||
|
} else {
|
||||||
|
$error = sprintf "TRX_LIGHT: error undefined subtype=%02x", $subtype;
|
||||||
|
Log 1, $error;
|
||||||
|
return $error;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $dev_first = "?";
|
||||||
|
|
||||||
|
my %x10_housecode =
|
||||||
|
(
|
||||||
|
0x41 => "A",
|
||||||
|
0x42 => "B",
|
||||||
|
0x43 => "C",
|
||||||
|
0x44 => "D",
|
||||||
|
0x45 => "E",
|
||||||
|
0x46 => "F",
|
||||||
|
0x47 => "G",
|
||||||
|
0x48 => "H",
|
||||||
|
0x49 => "I",
|
||||||
|
0x4A => "J",
|
||||||
|
0x4B => "K",
|
||||||
|
0x4C => "L",
|
||||||
|
0x4D => "M",
|
||||||
|
0x4E => "N",
|
||||||
|
0x4F => "O",
|
||||||
|
0x50 => "P",
|
||||||
|
);
|
||||||
|
my $devnr = $bytes->[3]; # housecode
|
||||||
|
if (exists $x10_housecode{$devnr}) {
|
||||||
|
$dev_first = $x10_housecode{$devnr};
|
||||||
|
} else {
|
||||||
|
$error = sprintf "TRX_SECURITY: x10_housecode wrong housecode=%02x", $devnr;
|
||||||
|
Log 1, $error;
|
||||||
|
return $error;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $unit = $bytes->[4]; # unitcode
|
||||||
|
|
||||||
|
my $device = sprintf '%s%0d', $dev_first, $unit;
|
||||||
|
|
||||||
|
my $data = $bytes->[5];
|
||||||
|
my $hexdata = sprintf '%02x', $data;
|
||||||
|
|
||||||
|
|
||||||
|
my $command = "";
|
||||||
|
if ($data == 0xff) {
|
||||||
|
$command = "illegal_cmd";
|
||||||
|
} else {
|
||||||
|
if (exists $light_device_commands{$subtype}) {
|
||||||
|
my $code = $light_device_commands{$subtype};
|
||||||
|
if (exists $code->[$data]) {
|
||||||
|
$command = $code->[$data];
|
||||||
|
} else {
|
||||||
|
$error = sprintf "TRX_LIGHT: out of range for subtype=%02x data=%02x", $subtype, $data;
|
||||||
|
Log 1, $error;
|
||||||
|
return $error;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#my @res;
|
||||||
|
my $current = "";
|
||||||
|
|
||||||
|
#--------------
|
||||||
|
my $device_name = "TRX".$DOT.$dev_type.$DOT.$device;
|
||||||
|
Log 1, "TRX_LIGHT: device_name=$device_name data=$hexdata" if ($TRX_LIGHT_debug == 1);
|
||||||
|
|
||||||
|
my $firstdevice = 1;
|
||||||
|
my $def = $modules{TRX_LIGHT}{defptr}{$device_name};
|
||||||
|
if(!$def) {
|
||||||
|
$firstdevice = 0;
|
||||||
|
$def = $modules{TRX_LIGHT}{defptr2}{$device_name};
|
||||||
|
if (!$def) {
|
||||||
|
Log 1, "UNDEFINED $device_name TRX_SECURITY $dev_type $device $dev_reading" if ($TRX_LIGHT_debug == 1);
|
||||||
|
Log 3, "TRX_LIGHT: TRX_LIGHT Unknown device $device_name, please define it";
|
||||||
|
return "UNDEFINED $device_name TRX_LIGHT $dev_type $device $dev_reading";
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
# Use $def->{NAME}, because the device may be renamed:
|
||||||
|
my $name = $def->{NAME};
|
||||||
|
|
||||||
|
Log 1, "TRX_LIGHT: $name devn=$device_name first=$firstdevice command=$command, cmd=$hexdata" if ($TRX_LIGHT_debug == 1);
|
||||||
|
|
||||||
|
my $n = 0;
|
||||||
|
my $tm = TimeNow();
|
||||||
|
my $val = "";
|
||||||
|
|
||||||
|
my $device_type = $def->{TRX_LIGHT_type};
|
||||||
|
|
||||||
|
my $sensor = "";
|
||||||
|
|
||||||
|
if ($device_type eq "MS14A") {
|
||||||
|
# for ms14a behave like x10, but flip second deviceid
|
||||||
|
$device_type = "X10";
|
||||||
|
if ($firstdevice == 1) {
|
||||||
|
$command = ($command eq "on") ? "alert" : "normal" ;
|
||||||
|
} else {
|
||||||
|
$command = ($command eq "on") ? "off" : "on" ;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#if ($device_type eq "X10") {
|
||||||
|
if (1) {
|
||||||
|
# try to use it for all types:
|
||||||
|
$current = $command;
|
||||||
|
|
||||||
|
$sensor = $firstdevice == 1 ? $def->{TRX_LIGHT_devicelog} : $def->{TRX_LIGHT_devicelog2};
|
||||||
|
$val .= $current;
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
} else {
|
||||||
|
Log 1, "TRX_LIGHT: X10 error unknown sensor type=$device_type $name devn=$device_name first=$firstdevice type=$command, user=$device (hex $hexdata)";
|
||||||
|
return "TRX_LIGHT X10 error unknown sensor type=$device_type for $device_name device=$device";
|
||||||
|
}
|
||||||
|
|
||||||
|
if (($firstdevice == 1) && $val) {
|
||||||
|
$def->{STATE} = $val;
|
||||||
|
$def->{TIME} = $tm;
|
||||||
|
$def->{CHANGED}[$n++] = $val;
|
||||||
|
}
|
||||||
|
|
||||||
|
DoTrigger($name, undef);
|
||||||
|
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_LIGHT_Parse($$)
|
||||||
|
{
|
||||||
|
my ($iohash, $hexline) = @_;
|
||||||
|
|
||||||
|
my $time = time();
|
||||||
|
# convert to binary
|
||||||
|
my $msg = pack('H*', $hexline);
|
||||||
|
if ($time_old ==0) {
|
||||||
|
Log 5, "TRX_LIGHT: decoding delay=0 hex=$hexline";
|
||||||
|
} else {
|
||||||
|
my $time_diff = $time - $time_old ;
|
||||||
|
Log 5, "TRX_LIGHT: decoding delay=$time_diff hex=$hexline";
|
||||||
|
}
|
||||||
|
$time_old = $time;
|
||||||
|
|
||||||
|
# convert string to array of bytes. Skip length byte
|
||||||
|
my @rfxcom_data_array = ();
|
||||||
|
foreach (split(//, substr($msg,1))) {
|
||||||
|
push (@rfxcom_data_array, ord($_) );
|
||||||
|
}
|
||||||
|
|
||||||
|
my $num_bytes = ord($msg);
|
||||||
|
|
||||||
|
if ($num_bytes < 3) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $type = $rfxcom_data_array[0];
|
||||||
|
|
||||||
|
#Log 1, "TRX_LIGHT: num_bytes=$num_bytes hex=$hexline type=$type" if ($TRX_LIGHT_debug == 1);
|
||||||
|
my $res = "";
|
||||||
|
if ($type == 0x10) {
|
||||||
|
Log 1, "TRX_LIGHT: X10 num_bytes=$num_bytes hex=$hexline" if ($TRX_LIGHT_debug == 1);
|
||||||
|
$res = TRX_LIGHT_parse_X10(\@rfxcom_data_array);
|
||||||
|
Log 1, "TRX_LIGHT: unsupported hex=$hexline" if ($res ne "" && $res !~ /^UNDEFINED.*/);
|
||||||
|
return $res;
|
||||||
|
} else {
|
||||||
|
Log 0, "TRX_LIGHT: not implemented num_bytes=$num_bytes hex=$hexline";
|
||||||
|
}
|
||||||
|
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
1;
|
||||||
401
fhem/FHEM/46_TRX_SECURITY.pm
Executable file
401
fhem/FHEM/46_TRX_SECURITY.pm
Executable file
@ -0,0 +1,401 @@
|
|||||||
|
#################################################################################
|
||||||
|
# 46_TRX_SECURITY.pm
|
||||||
|
#
|
||||||
|
# Modul for FHEM for X10, KD101, Visonic
|
||||||
|
# - X10 security messages tested for
|
||||||
|
# - ds10a: X10 Door / Window Sensor or compatible devices
|
||||||
|
# - ss10a: X10 motion sensor
|
||||||
|
# - sd90: Marmitek smoke detector
|
||||||
|
# - kr18: X10 remote control
|
||||||
|
#
|
||||||
|
##################################
|
||||||
|
#
|
||||||
|
# Willi Herzig, 2012
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
##################################
|
||||||
|
#
|
||||||
|
# Some code from X10security code is derived from http://www.xpl-perl.org.uk/.
|
||||||
|
# xpl-perl/lib/xPL/RF/X10Security.pm:
|
||||||
|
# Thanks a lot to Mark Hindess who wrote xPL.
|
||||||
|
#
|
||||||
|
#SEE ALSO
|
||||||
|
# Project website: http://www.xpl-perl.org.uk/
|
||||||
|
# AUTHOR: Mark Hindess, soft-xpl-perl@temporalanomaly.com
|
||||||
|
#
|
||||||
|
#Copyright (C) 2007, 2009 by Mark Hindess
|
||||||
|
#
|
||||||
|
#This library is free software; you can redistribute it and/or modify
|
||||||
|
#it under the same terms as Perl itself, either Perl version 5.8.7 or,
|
||||||
|
#at your option, any later version of Perl 5 you may have available.
|
||||||
|
#
|
||||||
|
##################################
|
||||||
|
#
|
||||||
|
# values for "set global verbose"
|
||||||
|
# 4: log unknown protocols
|
||||||
|
# 5: log decoding hexlines for debugging
|
||||||
|
#
|
||||||
|
# $Id: 43_TRX_SECURITY.pm 1098 2011-11-12 07:51:08Z rudolfkoenig $
|
||||||
|
package main;
|
||||||
|
|
||||||
|
use strict;
|
||||||
|
use warnings;
|
||||||
|
use Switch;
|
||||||
|
|
||||||
|
# Debug this module? YES = 1, NO = 0
|
||||||
|
my $TRX_SECURITY_debug = 0;
|
||||||
|
|
||||||
|
my $time_old = 0;
|
||||||
|
|
||||||
|
my $TRX_SECURITY_type_default = "ds10a";
|
||||||
|
|
||||||
|
my $DOT = q{_};
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_SECURITY_Initialize($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
$hash->{Match} = "^(\\ |\\)).*"; # 0x20 or 0x29
|
||||||
|
$hash->{DefFn} = "TRX_SECURITY_Define";
|
||||||
|
$hash->{UndefFn} = "TRX_SECURITY_Undef";
|
||||||
|
$hash->{ParseFn} = "TRX_SECURITY_Parse";
|
||||||
|
$hash->{AttrList} = "IODev do_not_notify:1,0 loglevel:0,1,2,3,4,5,6";
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_SECURITY_Define($$)
|
||||||
|
{
|
||||||
|
my ($hash, $def) = @_;
|
||||||
|
my @a = split("[ \t][ \t]*", $def);
|
||||||
|
|
||||||
|
my $a = int(@a);
|
||||||
|
|
||||||
|
if(int(@a) != 5 && int(@a) != 7) {
|
||||||
|
Log 1,"TRX_SECURITY wrong syntax '@a'. \nCorrect syntax is 'define <name> TRX_SECURITY <type> <deviceid> <devicelog> [<deviceid2> <devicelog2>]'";
|
||||||
|
return "wrong syntax: define <name> TRX_SECURITY <type> <deviceid> <devicelog> [<deviceid2> <devicelog2>]";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
my $name = $a[0];
|
||||||
|
|
||||||
|
my $type = lc($a[2]);
|
||||||
|
my $deviceid = $a[3];
|
||||||
|
my $devicelog = $a[4];
|
||||||
|
|
||||||
|
|
||||||
|
$type = uc($type);
|
||||||
|
|
||||||
|
my $device_name = "TRX".$DOT.$type.$DOT.$deviceid;
|
||||||
|
|
||||||
|
if ($type ne "DS10A" && $type ne "SD90" && $type ne "MS10A" && $type ne "MS14A" && $type ne "KR18" && $type ne "KD101" && $type ne "VISONIC_WINDOW" & $type ne "VISONIC_MOTION" & $type ne "VISONIC_REMOTE") {
|
||||||
|
Log 1,"RFX10SEC define: wrong type: $type";
|
||||||
|
return "RFX10SEC: wrong type: $type";
|
||||||
|
}
|
||||||
|
|
||||||
|
$hash->{TRX_SECURITY_deviceid} = $deviceid;
|
||||||
|
$hash->{TRX_SECURITY_devicelog} = $devicelog;
|
||||||
|
$hash->{TRX_SECURITY_type} = $type;
|
||||||
|
#$hash->{TRX_SECURITY_CODE} = $deviceid;
|
||||||
|
$modules{TRX_SECURITY}{defptr}{$device_name} = $hash;
|
||||||
|
|
||||||
|
|
||||||
|
if (int(@a) == 7) {
|
||||||
|
# there is a second deviceid:
|
||||||
|
#
|
||||||
|
my $deviceid2 = $a[5];
|
||||||
|
my $devicelog2 = $a[6];
|
||||||
|
|
||||||
|
my $device_name2 = "TRX_SECURITY".$DOT.$deviceid2;
|
||||||
|
|
||||||
|
$hash->{TRX_SECURITY_deviceid2} = $deviceid2;
|
||||||
|
$hash->{TRX_SECURITY_devicelog2} = $devicelog2;
|
||||||
|
#$hash->{TRX_SECURITY_CODE2} = $deviceid2;
|
||||||
|
$modules{TRX_SECURITY}{defptr2}{$device_name2} = $hash;
|
||||||
|
}
|
||||||
|
|
||||||
|
AssignIoPort($hash);
|
||||||
|
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_SECURITY_Undef($$)
|
||||||
|
{
|
||||||
|
my ($hash, $name) = @_;
|
||||||
|
delete($modules{TRX_SECURITY}{defptr}{$name});
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub TRX_SECURITY_parse_X10Sec {
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
my $error;
|
||||||
|
|
||||||
|
my $subtype = $bytes->[1];
|
||||||
|
|
||||||
|
my $device;
|
||||||
|
if ($subtype >= 3) {
|
||||||
|
$device = sprintf '%02x%02x%02x', $bytes->[3], $bytes->[4], $bytes->[5];
|
||||||
|
} else {
|
||||||
|
# that's how we do it on 43_RFXX10REC.pm
|
||||||
|
$device = sprintf '%02x%02x', $bytes->[5], $bytes->[3];
|
||||||
|
}
|
||||||
|
|
||||||
|
my %security_devtype =
|
||||||
|
( # HEXSTRING =>
|
||||||
|
0x00 => [ "DS10A", "Window" ], # X10 security door/window sensor
|
||||||
|
0x01 => [ "MS10A", "motion" ], # X10 security motion sensor
|
||||||
|
0x02 => [ "KR18", "key" ], # X10 security remote (no alive packets)
|
||||||
|
0x03 => [ "KD101", "smoke" ], # KD101 (no alive packets)
|
||||||
|
0x04 => [ "VISONIC_WINDOW", "window" ], # Visonic PowerCode door/window sensor – primary contact (with alive packets)
|
||||||
|
0x05 => [ "VISONIC_MOTION", "motion" ], # Visonic PowerCode motion sensor (with alive packets)
|
||||||
|
0x06 => [ "VISONIC_REMOTE", "key" ], # Visonic CodeSecure (no alive packets)
|
||||||
|
0x07 => [ "VISONIC_WINDOW", "window" ], # Visonic PowerCode door/window sensor – auxiliary contact (no alive packets)
|
||||||
|
);
|
||||||
|
|
||||||
|
my $dev_type;
|
||||||
|
my $dev_reading;
|
||||||
|
if (exists $security_devtype{$subtype}) {
|
||||||
|
my $rec = $security_devtype{$subtype};
|
||||||
|
if (ref $rec) {
|
||||||
|
($dev_type, $dev_reading ) = @$rec;
|
||||||
|
} else {
|
||||||
|
$error = "TRX_SECURITY: x10_devtype wrong for subtype=$subtype";
|
||||||
|
Log 1, $error;
|
||||||
|
return $error;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
$error = "TRX_SECURITY: error undefined subtype=$subtype";
|
||||||
|
Log 1, $error;
|
||||||
|
return $error;
|
||||||
|
}
|
||||||
|
|
||||||
|
#Log 4, "device_type=$device_type";
|
||||||
|
|
||||||
|
#--------------
|
||||||
|
my $device_name = "TRX".$DOT.$dev_type.$DOT.$device;
|
||||||
|
Log 4, "device_name=$device_name";
|
||||||
|
|
||||||
|
my $firstdevice = 1;
|
||||||
|
my $def = $modules{TRX_SECURITY}{defptr}{$device_name};
|
||||||
|
if(!$def) {
|
||||||
|
$firstdevice = 0;
|
||||||
|
$def = $modules{TRX_SECURITY}{defptr2}{$device_name};
|
||||||
|
if (!$def) {
|
||||||
|
Log 1, "UNDEFINED $device_name TRX_SECURITY $dev_type $device $dev_reading";
|
||||||
|
Log 3, "TRX_SECURITY: TRX_SECURITY Unknown device $device_name, please define it";
|
||||||
|
return "UNDEFINED $device_name TRX_SECURITY $dev_type $device $dev_reading";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
# Use $def->{NAME}, because the device may be renamed:
|
||||||
|
my $name = $def->{NAME};
|
||||||
|
|
||||||
|
my $data = $bytes->[6];
|
||||||
|
|
||||||
|
my $hexdata = sprintf '%02x', $data;
|
||||||
|
|
||||||
|
my %x10_security =
|
||||||
|
(
|
||||||
|
0x00 => ['X10Sec', 'normal', 'min_delay', ''],
|
||||||
|
0x01 => ['X10Sec', 'normal', 'max_delay', ''],
|
||||||
|
|
||||||
|
0x02 => ['X10Sec', 'alert', 'min_delay', ''],
|
||||||
|
0x03 => ['X10Sec', 'alert', 'max_delay', ''],
|
||||||
|
|
||||||
|
0x04 => ['X10Sec', 'alert', '', ''],
|
||||||
|
0x05 => ['X10Sec', 'normal', '', ''],
|
||||||
|
|
||||||
|
0x06 => ['X10Sec', 'alert', '', ''],
|
||||||
|
0x07 => ['X10Sec', 'normal', '', ''],
|
||||||
|
|
||||||
|
0x08 => ['X10Sec', 'tamper', '', ''],
|
||||||
|
|
||||||
|
0x09 => ['X10Sec', 'Security-Arm_Away', 'min_delay', ''], # kr18
|
||||||
|
0x0a => ['X10Sec', 'Security-Arm_Away', 'max_delay', ''], # kr18
|
||||||
|
0x0b => ['X10Sec', 'Security-Arm_Home', 'min_delay', ''], # kr18
|
||||||
|
0x0c => ['X10Sec', 'Security-Arm_Home', 'max_delay', ''], # kr18
|
||||||
|
0x0d => ['X10Sec', 'Security-Disarm', 'min_delay', ''], # kr18
|
||||||
|
|
||||||
|
0x10 => ['X10Sec', 'ButtonA-on', '', ''], # kr18
|
||||||
|
0x11 => ['X10Sec', 'ButtonA-off', '', ''], # kr18
|
||||||
|
0x12 => ['X10Sec', 'ButtonB-on', '', ''], # kr18
|
||||||
|
0x13 => ['X10Sec', 'ButtonB-off', '', ''], # kr18
|
||||||
|
|
||||||
|
0x14 => ['X10Sec', 'dark', '', ''],
|
||||||
|
0x15 => ['X10Sec', 'light', '', ''],
|
||||||
|
0x16 => ['X10Sec', 'normal', '', 'batt_low'],
|
||||||
|
|
||||||
|
0x17 => ['X10Sec', 'pair KD101', '', ''],
|
||||||
|
|
||||||
|
);
|
||||||
|
|
||||||
|
my $command = "";
|
||||||
|
my $type = "";
|
||||||
|
my $delay = "";
|
||||||
|
my $battery = "";
|
||||||
|
my @res;
|
||||||
|
if (exists $x10_security{$data}) {
|
||||||
|
my $rec = $x10_security{$data};
|
||||||
|
if (ref $rec) {
|
||||||
|
($type, $command, $delay, $battery) = @$rec;
|
||||||
|
} else {
|
||||||
|
$command = $rec;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Log 1, "TRX_SECURITY undefined command cmd=$data device-nr=$device, hex=$hexdata";
|
||||||
|
return "TRX_SECURITY undefined command";
|
||||||
|
}
|
||||||
|
|
||||||
|
my $battery_level = $bytes->[7] & 0x0f;
|
||||||
|
if (($battery eq "") && ($dev_type ne "kd101")) {
|
||||||
|
if ($battery_level == 0x9) { $battery = 'batt_ok'}
|
||||||
|
elsif ($battery_level == 0x0) { $battery = 'batt_low'}
|
||||||
|
else {
|
||||||
|
Log 1,"TRX-X10: X10Sec unkown battery_level=$battery_level";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
my $current = "";
|
||||||
|
|
||||||
|
Log 1, "TRX_SECURITY: $name devn=$device_name first=$firstdevice subtype=$subtype command=$command, delay=$delay, batt=$battery cmd=$hexdata" if ($TRX_SECURITY_debug == 1);
|
||||||
|
|
||||||
|
my $n = 0;
|
||||||
|
my $tm = TimeNow();
|
||||||
|
my $val = "";
|
||||||
|
|
||||||
|
my $device_type = $def->{TRX_SECURITY_type};
|
||||||
|
|
||||||
|
my $sensor = "";
|
||||||
|
|
||||||
|
if ($device_type eq "sd90") {
|
||||||
|
$sensor = $firstdevice == 1 ? $def->{TRX_SECURITY_devicelog} : $def->{TRX_SECURITY_devicelog2};
|
||||||
|
} else {
|
||||||
|
$sensor = $def->{TRX_SECURITY_devicelog};
|
||||||
|
}
|
||||||
|
|
||||||
|
$current =$command;
|
||||||
|
if (($device_type eq "DS10A") || ($device_type eq "VISONIC_WINDOW")) {
|
||||||
|
$current = "Error";
|
||||||
|
$current = "Open" if ($command eq "alert");
|
||||||
|
$current = "Closed" if ($command eq "normal");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (($dev_type ne "kr18") || ($dev_type ne "VISONIC_REMOTE")) {
|
||||||
|
if ($firstdevice == 1) {
|
||||||
|
$val .= $current;
|
||||||
|
}
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
|
||||||
|
if (($def->{STATE} ne $val)) {
|
||||||
|
$sensor = "statechange";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
# kr18 remote control or VISONIC_REMOTE
|
||||||
|
$current = $command;
|
||||||
|
|
||||||
|
#$sensor = $def->{TRX_SECURITY_devicelog};
|
||||||
|
$val = $current;
|
||||||
|
#$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
#$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
#$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
|
||||||
|
my @cmd_split = split(/-/, $command);
|
||||||
|
$sensor = $cmd_split[0];
|
||||||
|
$current = $cmd_split[1];
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ($battery ne "") {
|
||||||
|
$sensor = "battery";
|
||||||
|
$current = "Error";
|
||||||
|
$current = "ok" if ($battery eq "batt_ok");
|
||||||
|
$current = "low" if ($battery eq "batt_low");
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ($delay ne '') {
|
||||||
|
$sensor = "delay";
|
||||||
|
$current = "Error";
|
||||||
|
$current = "min" if ($delay eq "min_delay");
|
||||||
|
$current = "max" if ($delay eq "max_delay");
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $current;
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $current;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (($firstdevice == 1) && $val) {
|
||||||
|
$def->{STATE} = $val;
|
||||||
|
$def->{TIME} = $tm;
|
||||||
|
$def->{CHANGED}[$n++] = $val;
|
||||||
|
}
|
||||||
|
|
||||||
|
DoTrigger($name, undef);
|
||||||
|
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_SECURITY_Parse($$)
|
||||||
|
{
|
||||||
|
my ($iohash, $hexline) = @_;
|
||||||
|
|
||||||
|
my $time = time();
|
||||||
|
# convert to binary
|
||||||
|
my $msg = pack('H*', $hexline);
|
||||||
|
if ($time_old ==0) {
|
||||||
|
Log 5, "TRX_SECURITY: decoding delay=0 hex=$hexline";
|
||||||
|
} else {
|
||||||
|
my $time_diff = $time - $time_old ;
|
||||||
|
Log 5, "TRX_SECURITY: decoding delay=$time_diff hex=$hexline";
|
||||||
|
}
|
||||||
|
$time_old = $time;
|
||||||
|
|
||||||
|
# convert string to array of bytes. Skip length byte
|
||||||
|
my @rfxcom_data_array = ();
|
||||||
|
foreach (split(//, substr($msg,1))) {
|
||||||
|
push (@rfxcom_data_array, ord($_) );
|
||||||
|
}
|
||||||
|
|
||||||
|
my $num_bytes = ord($msg);
|
||||||
|
|
||||||
|
if ($num_bytes < 3) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $type = $rfxcom_data_array[0];
|
||||||
|
|
||||||
|
#Log 1, "TRX_SECURITY: X10Sec num_bytes=$num_bytes hex=$hexline type=$type" if ($TRX_SECURITY_debug == 1);
|
||||||
|
my $res = "";
|
||||||
|
if ($type == 0x20) {
|
||||||
|
Log 1, "TRX_SECURITY: X10Sec num_bytes=$num_bytes hex=$hexline" if ($TRX_SECURITY_debug == 1);
|
||||||
|
$res = TRX_SECURITY_parse_X10Sec(\@rfxcom_data_array);
|
||||||
|
Log 1, "TRX_SECURITY: unsupported hex=$hexline" if ($res ne "" && $res !~ /^UNDEFINED.*/);
|
||||||
|
return $res;
|
||||||
|
} else {
|
||||||
|
Log 0, "TRX_SECURITY: not implemented num_bytes=$num_bytes hex=$hexline";
|
||||||
|
}
|
||||||
|
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
1;
|
||||||
828
fhem/FHEM/46_TRX_WEATHER.pm
Executable file
828
fhem/FHEM/46_TRX_WEATHER.pm
Executable file
@ -0,0 +1,828 @@
|
|||||||
|
#################################################################################
|
||||||
|
# 46_TRX_WEATHER.pm
|
||||||
|
# Module for FHEM to decode weather sensor messages for RFXtrx
|
||||||
|
#
|
||||||
|
# The following devices are implemented to be received:
|
||||||
|
#
|
||||||
|
# temperature sensors (TEMP):
|
||||||
|
# * "THR128" is THR128/138, THC138
|
||||||
|
# * "THGR132N" is THC238/268,THN132,THWR288,THRN122,THN122,AW129/131
|
||||||
|
# * "THWR800" is THWR800
|
||||||
|
# * "RTHN318" is RTHN318
|
||||||
|
# * "TX3_T" is LaCrosse TX3, TX4, TX17
|
||||||
|
#
|
||||||
|
# temperature/humidity sensors (TEMPHYDRO):
|
||||||
|
# * "THGR228N" is THGN122/123, THGN132, THGR122/228/238/268
|
||||||
|
# * "THGR810" is THGR810
|
||||||
|
# * "RTGR328" is RTGR328
|
||||||
|
# * "THGR328" is THGR328
|
||||||
|
# * "WTGR800_T" is WTGR800
|
||||||
|
# * "THGR918" is THGR918, THGRN228, THGN500
|
||||||
|
# * "TFATS34C" is TFA TS34C
|
||||||
|
#
|
||||||
|
# temperature/humidity/pressure sensors (TEMPHYDROBARO):
|
||||||
|
# * "BTHR918" is BTHR918
|
||||||
|
# * "BTHR918N" is BTHR918N, BTHR968
|
||||||
|
#
|
||||||
|
# rain gauge sensors (RAIN):
|
||||||
|
# * "RGR918" is RGR126/682/918
|
||||||
|
# * "PCR800" is PCR800
|
||||||
|
# * "TFA_RAIN" is TFA
|
||||||
|
#
|
||||||
|
# wind sensors (WIND):
|
||||||
|
# * "WTGR800_A" is WTGR800
|
||||||
|
# * "WGR800_A" is WGR800
|
||||||
|
# * "WGR918_A" is STR918, WGR918
|
||||||
|
# * "TFA_WIND" is TFA
|
||||||
|
#
|
||||||
|
# derived from 41_OREGON.pm
|
||||||
|
#
|
||||||
|
# Willi Herzig, 2012
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
#
|
||||||
|
##################################
|
||||||
|
#
|
||||||
|
# values for "set global verbose"
|
||||||
|
# 4: log unknown protocols
|
||||||
|
# 5: log decoding hexlines for debugging
|
||||||
|
#
|
||||||
|
# $Id:
|
||||||
|
package main;
|
||||||
|
|
||||||
|
use strict;
|
||||||
|
use warnings;
|
||||||
|
|
||||||
|
# Hex-Debugging into READING hexline? YES = 1, NO = 0
|
||||||
|
my $TRX_HEX_debug = 0;
|
||||||
|
|
||||||
|
my $time_old = 0;
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_WEATHER_Initialize($)
|
||||||
|
{
|
||||||
|
my ($hash) = @_;
|
||||||
|
|
||||||
|
$hash->{Match} = "^[\x38-\x78].*";
|
||||||
|
#$hash->{Match} = "^[^\x30]";
|
||||||
|
$hash->{DefFn} = "TRX_WEATHER_Define";
|
||||||
|
$hash->{UndefFn} = "TRX_WEATHER_Undef";
|
||||||
|
$hash->{ParseFn} = "TRX_WEATHER_Parse";
|
||||||
|
$hash->{AttrList} = "IODev do_not_notify:1,0 loglevel:0,1,2,3,4,5,6";
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_WEATHER_Define($$)
|
||||||
|
{
|
||||||
|
my ($hash, $def) = @_;
|
||||||
|
my @a = split("[ \t][ \t]*", $def);
|
||||||
|
|
||||||
|
my $a = int(@a);
|
||||||
|
#print "a0 = $a[0]";
|
||||||
|
return "wrong syntax: define <name> TRX_WEATHER code" if(int(@a) != 3);
|
||||||
|
|
||||||
|
my $name = $a[0];
|
||||||
|
my $code = $a[2];
|
||||||
|
|
||||||
|
$hash->{CODE} = $code;
|
||||||
|
#$modules{TRX_WEATHER}{defptr}{$name} = $hash;
|
||||||
|
$modules{TRX_WEATHER}{defptr}{$code} = $hash;
|
||||||
|
AssignIoPort($hash);
|
||||||
|
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
#####################################
|
||||||
|
sub
|
||||||
|
TRX_WEATHER_Undef($$)
|
||||||
|
{
|
||||||
|
my ($hash, $name) = @_;
|
||||||
|
delete($modules{TRX_WEATHER}{defptr}{$name});
|
||||||
|
return undef;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#########################################
|
||||||
|
# From xpl-perl/lib/xPL/Util.pm:
|
||||||
|
sub hi_nibble {
|
||||||
|
($_[0]&0xf0)>>4;
|
||||||
|
}
|
||||||
|
sub lo_nibble {
|
||||||
|
$_[0]&0xf;
|
||||||
|
}
|
||||||
|
sub nibble_sum {
|
||||||
|
my $c = $_[0];
|
||||||
|
my $s = 0;
|
||||||
|
foreach (0..$_[0]-1) {
|
||||||
|
$s += hi_nibble($_[1]->[$_]);
|
||||||
|
$s += lo_nibble($_[1]->[$_]);
|
||||||
|
}
|
||||||
|
$s += hi_nibble($_[1]->[$_[0]]) if (int($_[0]) != $_[0]);
|
||||||
|
return $s;
|
||||||
|
}
|
||||||
|
|
||||||
|
# --------------------------------------------
|
||||||
|
# From xpl-perl/lib/xPL/RF/Oregon.pm:
|
||||||
|
# This function creates a simple key from a device type and message
|
||||||
|
# length (in bits). It is used to as the index for the parts table.
|
||||||
|
sub type_length_key {
|
||||||
|
($_[0] << 8) + $_[1]
|
||||||
|
}
|
||||||
|
|
||||||
|
# --------------------------------------------
|
||||||
|
# sensor types
|
||||||
|
|
||||||
|
my %types =
|
||||||
|
(
|
||||||
|
# TEMP
|
||||||
|
type_length_key(0x50, 0x08) =>
|
||||||
|
{
|
||||||
|
part => 'TEMP', method => \&common_temp,
|
||||||
|
},
|
||||||
|
# TEMP HYDRO
|
||||||
|
type_length_key(0x52, 0x0a) =>
|
||||||
|
{
|
||||||
|
part => 'TEMPHYDRO', method => \&common_temphydro,
|
||||||
|
},
|
||||||
|
# TEMP HYDRO BARO
|
||||||
|
type_length_key(0x54, 0x0d) =>
|
||||||
|
{
|
||||||
|
part => 'TEMPHYDROBARO', method => \&common_temphydrobaro,
|
||||||
|
},
|
||||||
|
# RAIN
|
||||||
|
type_length_key(0x55, 0x0b) =>
|
||||||
|
{
|
||||||
|
part => 'RAIN', method => \&common_rain,
|
||||||
|
},
|
||||||
|
# WIND
|
||||||
|
type_length_key(0x56, 0x10) =>
|
||||||
|
{
|
||||||
|
part => 'WIND', method => \&common_anemometer,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------
|
||||||
|
|
||||||
|
#my $DOT = q{.};
|
||||||
|
# Important: change it to _, because FHEM uses regexp
|
||||||
|
my $DOT = q{_};
|
||||||
|
|
||||||
|
my @TRX_WEATHER_winddir_name=("N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW");
|
||||||
|
|
||||||
|
# --------------------------------------------
|
||||||
|
# The following functions are changed:
|
||||||
|
# - some parameter like "parent" and others are removed
|
||||||
|
# - @res array return the values directly (no usage of xPL::Message)
|
||||||
|
|
||||||
|
sub temperature {
|
||||||
|
my ($bytes, $dev, $res, $off) = @_;
|
||||||
|
|
||||||
|
my $temp =
|
||||||
|
(
|
||||||
|
(($bytes->[$off] & 0x80) ? -1 : 1) *
|
||||||
|
(($bytes->[$off] & 0x7f)*256 + $bytes->[$off+1])
|
||||||
|
)/10;
|
||||||
|
|
||||||
|
push @$res, {
|
||||||
|
device => $dev,
|
||||||
|
type => 'temp',
|
||||||
|
current => $temp,
|
||||||
|
units => 'Grad Celsius'
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
sub humidity {
|
||||||
|
my ($bytes, $dev, $res, $off) = @_;
|
||||||
|
my $hum = $bytes->[$off];
|
||||||
|
my $hum_str = ['dry', 'comfortable', 'normal', 'wet']->[$bytes->[$off+1]];
|
||||||
|
push @$res, {
|
||||||
|
device => $dev,
|
||||||
|
type => 'humidity',
|
||||||
|
current => $hum,
|
||||||
|
string => $hum_str,
|
||||||
|
units => '%'
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
sub pressure {
|
||||||
|
my ($bytes, $dev, $res, $off) = @_;
|
||||||
|
|
||||||
|
#my $offset = 795 unless ($offset);
|
||||||
|
my $hpa = ($bytes->[$off])*256 + $bytes->[$off+1];
|
||||||
|
my $forecast = { 0x00 => 'noforecast',
|
||||||
|
0x01 => 'sunny',
|
||||||
|
0x02 => 'partly',
|
||||||
|
0x03 => 'cloudy',
|
||||||
|
0x04 => 'rain',
|
||||||
|
}->{$bytes->[$off+2]} || 'unknown';
|
||||||
|
push @$res, {
|
||||||
|
device => $dev,
|
||||||
|
type => 'pressure',
|
||||||
|
current => $hpa,
|
||||||
|
units => 'hPa',
|
||||||
|
forecast => $forecast,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
sub simple_battery {
|
||||||
|
my ($bytes, $dev, $res, $off) = @_;
|
||||||
|
|
||||||
|
my $battery;
|
||||||
|
|
||||||
|
my $battery_level = $bytes->[$off] & 0x0f;
|
||||||
|
if ($battery_level == 0x9) { $battery = 'ok'}
|
||||||
|
elsif ($battery_level == 0x0) { $battery = 'low'}
|
||||||
|
else {
|
||||||
|
$battery = sprintf("unknown-%02x",$battery_level);
|
||||||
|
}
|
||||||
|
|
||||||
|
push @$res, {
|
||||||
|
device => $dev,
|
||||||
|
type => 'battery',
|
||||||
|
current => $battery,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
sub battery {
|
||||||
|
my ($bytes, $dev, $res, $off) = @_;
|
||||||
|
|
||||||
|
my $battery;
|
||||||
|
|
||||||
|
my $battery_level = ($bytes->[$off] & 0x0f) + 1;
|
||||||
|
|
||||||
|
if ($battery_level > 5) {
|
||||||
|
$battery = sprintf("ok %d0%%",$battery_level);
|
||||||
|
} else {
|
||||||
|
$battery = sprintf("low %d0%%",$battery_level);
|
||||||
|
}
|
||||||
|
|
||||||
|
push @$res, {
|
||||||
|
device => $dev,
|
||||||
|
type => 'battery',
|
||||||
|
current => $battery,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
my @uv_str =
|
||||||
|
(
|
||||||
|
qw/low low low/, # 0 - 2
|
||||||
|
qw/medium medium medium/, # 3 - 5
|
||||||
|
qw/high high/, # 6 - 7
|
||||||
|
'very high', 'very high', 'very high', # 8 - 10
|
||||||
|
);
|
||||||
|
|
||||||
|
sub uv_string {
|
||||||
|
$uv_str[$_[0]] || 'dangerous';
|
||||||
|
}
|
||||||
|
|
||||||
|
# Test if to use longid for device type
|
||||||
|
sub use_longid {
|
||||||
|
my ($longids,$dev_type) = @_;
|
||||||
|
|
||||||
|
return 0 if ($longids eq "");
|
||||||
|
return 0 if ($longids eq "0");
|
||||||
|
|
||||||
|
return 1 if ($longids eq "1");
|
||||||
|
return 1 if ($longids eq "ALL");
|
||||||
|
|
||||||
|
return 1 if(",$longids," =~ m/,$dev_type,/);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
# ------------------------------------------------------------
|
||||||
|
#
|
||||||
|
sub common_anemometer {
|
||||||
|
my $type = shift;
|
||||||
|
my $longids = shift;
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
my $subtype = sprintf "%02x", $bytes->[1];
|
||||||
|
#Log 1,"subtype=$subtype";
|
||||||
|
my $dev_type;
|
||||||
|
|
||||||
|
my %devname =
|
||||||
|
( # HEXSTRING => "NAME"
|
||||||
|
0x01 => "WTGR800_A",
|
||||||
|
0x02 => "WGR800_A",
|
||||||
|
0x03 => "WGR918_A",
|
||||||
|
0x04 => "TFA_WIND",
|
||||||
|
);
|
||||||
|
|
||||||
|
if (exists $devname{$bytes->[1]}) {
|
||||||
|
$dev_type = $devname{$bytes->[1]};
|
||||||
|
} else {
|
||||||
|
Log 1,"TRX_WEATHER: error undefined subtype=$subtype";
|
||||||
|
my @res = ();
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
#my $seqnbr = sprintf "%02x", $bytes->[2];
|
||||||
|
#Log 1,"seqnbr=$seqnbr";
|
||||||
|
|
||||||
|
my $dev_str = $dev_type;
|
||||||
|
if (use_longid($longids,$dev_type)) {
|
||||||
|
$dev_str .= $DOT.sprintf("%02x", $bytes->[3]);
|
||||||
|
}
|
||||||
|
if ($bytes->[4] > 0) {
|
||||||
|
$dev_str .= $DOT.sprintf("%d", $bytes->[4]);
|
||||||
|
}
|
||||||
|
|
||||||
|
my @res = ();
|
||||||
|
|
||||||
|
# hexline debugging
|
||||||
|
if ($TRX_HEX_debug) {
|
||||||
|
my $hexline = ""; for (my $i=0;$i<@$bytes;$i++) { $hexline .= sprintf("%02x",$bytes->[$i]);}
|
||||||
|
push @res, { device => $dev_str, type => 'hexline', current => $hexline, units => 'hex', };
|
||||||
|
}
|
||||||
|
|
||||||
|
my $dir = $bytes->[5]*256 + $bytes->[6];
|
||||||
|
my $dirname = $TRX_WEATHER_winddir_name[$dir/22.5];
|
||||||
|
|
||||||
|
my $avspeed = $bytes->[7]*256 + $bytes->[8];
|
||||||
|
my $speed = $bytes->[9]*256 + $bytes->[10];
|
||||||
|
|
||||||
|
push @res, {
|
||||||
|
device => $dev_str,
|
||||||
|
type => 'speed',
|
||||||
|
current => $speed,
|
||||||
|
average => $avspeed,
|
||||||
|
units => 'mps',
|
||||||
|
} , {
|
||||||
|
device => $dev_str,
|
||||||
|
type => 'direction',
|
||||||
|
current => $dir,
|
||||||
|
string => $dirname,
|
||||||
|
units => 'degrees',
|
||||||
|
}
|
||||||
|
;
|
||||||
|
simple_battery($bytes, $dev_str, \@res, 15);
|
||||||
|
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# -----------------------------
|
||||||
|
sub common_temp {
|
||||||
|
my $type = shift;
|
||||||
|
my $longids = shift;
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
my $subtype = sprintf "%02x", $bytes->[1];
|
||||||
|
#Log 1,"subtype=$subtype";
|
||||||
|
my $dev_type;
|
||||||
|
|
||||||
|
my %devname =
|
||||||
|
( # HEXSTRING => "NAME"
|
||||||
|
0x01 => "THR128",
|
||||||
|
0x02 => "THGR132N", # was THGR228N,
|
||||||
|
0x03 => "THWR800",
|
||||||
|
0x04 => "RTHN318",
|
||||||
|
0x05 => "TX3_T",
|
||||||
|
);
|
||||||
|
|
||||||
|
if (exists $devname{$bytes->[1]}) {
|
||||||
|
$dev_type = $devname{$bytes->[1]};
|
||||||
|
} else {
|
||||||
|
Log 1,"RFX_WEATHER: error undefined subtype=$subtype";
|
||||||
|
my @res = ();
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
#my $seqnbr = sprintf "%02x", $bytes->[2];
|
||||||
|
#Log 1,"seqnbr=$seqnbr";
|
||||||
|
|
||||||
|
my $dev_str = $dev_type;
|
||||||
|
if (use_longid($longids,$dev_type)) {
|
||||||
|
$dev_str .= $DOT.sprintf("%02x", $bytes->[3]);
|
||||||
|
}
|
||||||
|
if ($bytes->[4] > 0) {
|
||||||
|
$dev_str .= $DOT.sprintf("%d", $bytes->[4]);
|
||||||
|
}
|
||||||
|
#Log 1,"dev_str=$dev_str";
|
||||||
|
|
||||||
|
my @res = ();
|
||||||
|
|
||||||
|
# hexline debugging
|
||||||
|
if ($TRX_HEX_debug) {
|
||||||
|
my $hexline = ""; for (my $i=0;$i<@$bytes;$i++) { $hexline .= sprintf("%02x",$bytes->[$i]);}
|
||||||
|
push @res, { device => $dev_str, type => 'hexline', current => $hexline, units => 'hex', };
|
||||||
|
}
|
||||||
|
|
||||||
|
temperature($bytes, $dev_str, \@res, 5);
|
||||||
|
simple_battery($bytes, $dev_str, \@res, 7);
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
# -----------------------------
|
||||||
|
sub common_temphydro {
|
||||||
|
my $type = shift;
|
||||||
|
my $longids = shift;
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
my $subtype = sprintf "%02x", $bytes->[1];
|
||||||
|
#Log 1,"subtype=$subtype";
|
||||||
|
my $dev_type;
|
||||||
|
|
||||||
|
my %devname =
|
||||||
|
( # HEXSTRING => "NAME"
|
||||||
|
0x01 => "THGR228N", # THGN122/123, THGN132, THGR122/228/238/268
|
||||||
|
0x02 => "THGR810",
|
||||||
|
0x03 => "RTGR328",
|
||||||
|
0x04 => "THGR328",
|
||||||
|
0x05 => "WTGR800_T",
|
||||||
|
0x06 => "THGR918",
|
||||||
|
0x07 => "TFATS34C",
|
||||||
|
);
|
||||||
|
|
||||||
|
if (exists $devname{$bytes->[1]}) {
|
||||||
|
$dev_type = $devname{$bytes->[1]};
|
||||||
|
} else {
|
||||||
|
Log 1,"RFX_WEATHER: error undefined subtype=$subtype";
|
||||||
|
my @res = ();
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $dev_str = $dev_type;
|
||||||
|
if (use_longid($longids,$dev_type)) {
|
||||||
|
$dev_str .= $DOT.sprintf("%02x", $bytes->[3]);
|
||||||
|
}
|
||||||
|
if ($bytes->[4] > 0) {
|
||||||
|
$dev_str .= $DOT.sprintf("%d", $bytes->[4]);
|
||||||
|
}
|
||||||
|
#Log 1,"dev_str=$dev_str";
|
||||||
|
|
||||||
|
my @res = ();
|
||||||
|
|
||||||
|
# hexline debugging
|
||||||
|
if ($TRX_HEX_debug) {
|
||||||
|
my $hexline = ""; for (my $i=0;$i<@$bytes;$i++) { $hexline .= sprintf("%02x",$bytes->[$i]);}
|
||||||
|
push @res, { device => $dev_str, type => 'hexline', current => $hexline, units => 'hex', };
|
||||||
|
}
|
||||||
|
|
||||||
|
temperature($bytes, $dev_str, \@res, 5);
|
||||||
|
humidity($bytes, $dev_str, \@res, 7);
|
||||||
|
simple_battery($bytes, $dev_str, \@res, 9);
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
# -----------------------------
|
||||||
|
sub common_temphydrobaro {
|
||||||
|
my $type = shift;
|
||||||
|
my $longids = shift;
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
my $subtype = sprintf "%02x", $bytes->[1];
|
||||||
|
#Log 1,"subtype=$subtype";
|
||||||
|
my $dev_type;
|
||||||
|
|
||||||
|
my %devname =
|
||||||
|
( # HEXSTRING => "NAME"
|
||||||
|
0x01 => "BTHR918",
|
||||||
|
0x02 => "BTHR918N",
|
||||||
|
);
|
||||||
|
|
||||||
|
if (exists $devname{$bytes->[1]}) {
|
||||||
|
$dev_type = $devname{$bytes->[1]};
|
||||||
|
} else {
|
||||||
|
Log 1,"RFX_WEATHER: error undefined subtype=$subtype";
|
||||||
|
my @res = ();
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $dev_str = $dev_type;
|
||||||
|
if (use_longid($longids,$dev_type)) {
|
||||||
|
$dev_str .= $DOT.sprintf("%02x", $bytes->[3]);
|
||||||
|
}
|
||||||
|
if ($bytes->[4] > 0) {
|
||||||
|
$dev_str .= $DOT.sprintf("%d", $bytes->[4]);
|
||||||
|
}
|
||||||
|
#Log 1,"dev_str=$dev_str";
|
||||||
|
|
||||||
|
my @res = ();
|
||||||
|
|
||||||
|
# hexline debugging
|
||||||
|
if ($TRX_HEX_debug) {
|
||||||
|
my $hexline = ""; for (my $i=0;$i<@$bytes;$i++) { $hexline .= sprintf("%02x",$bytes->[$i]);}
|
||||||
|
push @res, { device => $dev_str, type => 'hexline', current => $hexline, units => 'hex', };
|
||||||
|
}
|
||||||
|
|
||||||
|
temperature($bytes, $dev_str, \@res, 5);
|
||||||
|
humidity($bytes, $dev_str, \@res, 7);
|
||||||
|
pressure($bytes, $dev_str, \@res, 9);
|
||||||
|
simple_battery($bytes, $dev_str, \@res, 12);
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
# -----------------------------
|
||||||
|
sub common_rain {
|
||||||
|
my $type = shift;
|
||||||
|
my $longids = shift;
|
||||||
|
my $bytes = shift;
|
||||||
|
|
||||||
|
|
||||||
|
my $subtype = sprintf "%02x", $bytes->[1];
|
||||||
|
#Log 1,"subtype=$subtype";
|
||||||
|
my $dev_type;
|
||||||
|
|
||||||
|
my %devname =
|
||||||
|
( # HEXSTRING => "NAME"
|
||||||
|
0x01 => "RGR918",
|
||||||
|
0x02 => "PCR800",
|
||||||
|
0x03 => "TFA_RAIN",
|
||||||
|
);
|
||||||
|
|
||||||
|
if (exists $devname{$bytes->[1]}) {
|
||||||
|
$dev_type = $devname{$bytes->[1]};
|
||||||
|
} else {
|
||||||
|
Log 1,"RFX_WEATHER: error undefined subtype=$subtype";
|
||||||
|
my @res = ();
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $dev_str = $dev_type;
|
||||||
|
if (use_longid($longids,$dev_type)) {
|
||||||
|
$dev_str .= $DOT.sprintf("%02x", $bytes->[3]);
|
||||||
|
}
|
||||||
|
if ($bytes->[4] > 0) {
|
||||||
|
$dev_str .= $DOT.sprintf("%d", $bytes->[4]);
|
||||||
|
}
|
||||||
|
#Log 1,"dev_str=$dev_str";
|
||||||
|
|
||||||
|
my @res = ();
|
||||||
|
|
||||||
|
# hexline debugging
|
||||||
|
if ($TRX_HEX_debug) {
|
||||||
|
my $hexline = ""; for (my $i=0;$i<@$bytes;$i++) { $hexline .= sprintf("%02x",$bytes->[$i]);}
|
||||||
|
push @res, { device => $dev_str, type => 'hexline', current => $hexline, units => 'hex', };
|
||||||
|
}
|
||||||
|
|
||||||
|
my $rain = $bytes->[5]*256 + $bytes->[6];
|
||||||
|
my $train = $bytes->[7]*256*256 + $bytes->[8]*256 + $bytes->[9];
|
||||||
|
|
||||||
|
push @res, {
|
||||||
|
device => $dev_str,
|
||||||
|
type => 'rain',
|
||||||
|
current => $rain,
|
||||||
|
units => 'mm/h',
|
||||||
|
} ;
|
||||||
|
push @res, {
|
||||||
|
device => $dev_str,
|
||||||
|
type => 'train',
|
||||||
|
current => $train,
|
||||||
|
units => 'mm',
|
||||||
|
};
|
||||||
|
battery($bytes, $dev_str, \@res, 10);
|
||||||
|
return @res;
|
||||||
|
}
|
||||||
|
|
||||||
|
sub raw {
|
||||||
|
$_[0]->{raw} or $_[0]->{raw} = pack 'H*', $_[0]->{hex};
|
||||||
|
}
|
||||||
|
|
||||||
|
# -----------------------------
|
||||||
|
|
||||||
|
sub
|
||||||
|
TRX_WEATHER_Parse($$)
|
||||||
|
{
|
||||||
|
my ($iohash, $hexline) = @_;
|
||||||
|
|
||||||
|
#my $hashname = $iohash->{NAME};
|
||||||
|
#my $longid = AttrVal($hashname,"longids","");
|
||||||
|
#Log 1,"2: name=$hashname, attr longids = $longid";
|
||||||
|
|
||||||
|
my $longids = 0;
|
||||||
|
if (defined($attr{$iohash->{NAME}}{longids})) {
|
||||||
|
$longids = $attr{$iohash->{NAME}}{longids};
|
||||||
|
#Log 1,"0: attr longids = $longids";
|
||||||
|
}
|
||||||
|
|
||||||
|
my $time = time();
|
||||||
|
# convert to binary
|
||||||
|
my $msg = pack('H*', $hexline);
|
||||||
|
if ($time_old ==0) {
|
||||||
|
Log 5, "TRX_WEATHER: decoding delay=0 hex=$hexline";
|
||||||
|
} else {
|
||||||
|
my $time_diff = $time - $time_old ;
|
||||||
|
Log 5, "TRX_WEATHER: decoding delay=$time_diff hex=$hexline";
|
||||||
|
}
|
||||||
|
$time_old = $time;
|
||||||
|
|
||||||
|
# convert string to array of bytes. Skip length byte
|
||||||
|
my @rfxcom_data_array = ();
|
||||||
|
foreach (split(//, substr($msg,1))) {
|
||||||
|
push (@rfxcom_data_array, ord($_) );
|
||||||
|
}
|
||||||
|
|
||||||
|
my $num_bytes = ord($msg);
|
||||||
|
|
||||||
|
if ($num_bytes < 3) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
my $type = $rfxcom_data_array[0];
|
||||||
|
|
||||||
|
my $sensor_id = unpack('H*', chr $type);
|
||||||
|
#Log 1, "TRX_WEATHER: sensor_id=$sensor_id";
|
||||||
|
|
||||||
|
my $key = type_length_key($type, $num_bytes);
|
||||||
|
|
||||||
|
my $rec = $types{$key} || $types{$key&0xfffff};
|
||||||
|
unless ($rec) {
|
||||||
|
#Log 3, "TRX_WEATHER: ERROR: Unknown sensor_id=$sensor_id num_bytes=$num_bytes message='$hexline'.";
|
||||||
|
Log 4, "TRX_WEATHER: ERROR: Unknown sensor_id=$sensor_id message='$hexline'";
|
||||||
|
Log 1, "TRX_WEATHER: ERROR: Unknown sensor_id=$sensor_id message='$hexline'";
|
||||||
|
return "TRX_WEATHER: ERROR: Unknown sensor_id=$sensor_id \n";
|
||||||
|
}
|
||||||
|
|
||||||
|
my $method = $rec->{method};
|
||||||
|
unless ($method) {
|
||||||
|
Log 4, "TRX_WEATHER: Possible message from Oregon part '$rec->{part}'";
|
||||||
|
Log 4, "TRX_WEATHER: sensor_id=$sensor_id";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
my @res;
|
||||||
|
|
||||||
|
if (! defined(&$method)) {
|
||||||
|
Log 4, "TRX_WEATHER: Error: Unknown function=$method. Please define it in file $0";
|
||||||
|
Log 4, "TRX_WEATHER: sensor_id=$sensor_id\n";
|
||||||
|
return "TRX_WEATHER: Error: Unknown function=$method. Please define it in file $0";
|
||||||
|
} else {
|
||||||
|
#Log 1, "TRX_WEATHER: parsing sensor_id=$sensor_id message='$hexline'";
|
||||||
|
@res = $method->($rec->{part}, $longids, \@rfxcom_data_array);
|
||||||
|
}
|
||||||
|
|
||||||
|
# get device name from first entry
|
||||||
|
my $device_name = $res[0]->{device};
|
||||||
|
#Log 1, "device_name=$device_name";
|
||||||
|
|
||||||
|
if (! defined($device_name)) {
|
||||||
|
Log 4, "TRX_WEATHER: error device_name undefined\n";
|
||||||
|
return "TRX_WEATHER: Error: Unknown devicename.";
|
||||||
|
}
|
||||||
|
|
||||||
|
my $def = $modules{TRX_WEATHER}{defptr}{"$device_name"};
|
||||||
|
if(!$def) {
|
||||||
|
Log 3, "TRX_WEATHER: Unknown device $device_name, please define it";
|
||||||
|
return "UNDEFINED $device_name TRX_WEATHER $device_name";
|
||||||
|
}
|
||||||
|
# Use $def->{NAME}, because the device may be renamed:
|
||||||
|
my $name = $def->{NAME};
|
||||||
|
#Log 1, "name=$new_name";
|
||||||
|
|
||||||
|
my $n = 0;
|
||||||
|
my $tm = TimeNow();
|
||||||
|
|
||||||
|
my $i;
|
||||||
|
my $val = "";
|
||||||
|
my $sensor = "";
|
||||||
|
foreach $i (@res){
|
||||||
|
#print "!> i=".$i."\n";
|
||||||
|
#printf "%s\t",$i->{device};
|
||||||
|
if ($i->{type} eq "temp") {
|
||||||
|
#printf "Temperatur %2.1f %s ; ",$i->{current},$i->{units};
|
||||||
|
$val .= "T: ".$i->{current}." ";
|
||||||
|
|
||||||
|
$sensor = "temperature";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "humidity") {
|
||||||
|
#printf "Luftfeuchtigkeit %d%s, %s ;",$i->{current},$i->{units},$i->{string};
|
||||||
|
$val .= "H: ".$i->{current}." ";
|
||||||
|
|
||||||
|
$sensor = "humidity";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "battery") {
|
||||||
|
#printf "Batterie %d%s; ",$i->{current},$i->{units};
|
||||||
|
my $tmp_battery = $i->{current};
|
||||||
|
my @words = split(/\s+/,$i->{current});
|
||||||
|
$val .= "BAT: ".$words[0]." "; #user only first word
|
||||||
|
|
||||||
|
$sensor = "battery";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "pressure") {
|
||||||
|
#printf "Luftdruck %d %s, Vorhersage=%s ; ",$i->{current},$i->{units},$i->{forecast};
|
||||||
|
# do not add it due to problems with hms.gplot
|
||||||
|
$val .= "P: ".$i->{current}." ";
|
||||||
|
|
||||||
|
$sensor = "pressure";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
|
||||||
|
$sensor = "forecast";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{forecast};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{forecast};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "speed") {
|
||||||
|
$val .= "W: ".$i->{current}." ";
|
||||||
|
$val .= "WA: ".$i->{average}." ";
|
||||||
|
|
||||||
|
$sensor = "wind_speed";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
|
||||||
|
$sensor = "wind_avspeed";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{average};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{average};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "direction") {
|
||||||
|
$val .= "WD: ".$i->{current}." ";
|
||||||
|
$val .= "WDN: ".$i->{string}." ";
|
||||||
|
|
||||||
|
$sensor = "wind_dir";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current} . " " . $i->{string};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current} . " " . $i->{string};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "rain") {
|
||||||
|
$val .= "RR: ".$i->{current}." ";
|
||||||
|
|
||||||
|
$sensor = "rain_rate";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "train") {
|
||||||
|
$val .= "TR: ".$i->{current}." ";
|
||||||
|
|
||||||
|
$sensor = "rain_total";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "flip") {
|
||||||
|
$val .= "F: ".$i->{current}." ";
|
||||||
|
|
||||||
|
$sensor = "rain_flip";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "uv") {
|
||||||
|
$val .= "UV: ".$i->{current}." ";
|
||||||
|
$val .= "UVR: ".$i->{risk}." ";
|
||||||
|
|
||||||
|
$sensor = "uv_val";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
|
||||||
|
$sensor = "uv_risk";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{risk};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{risk};;
|
||||||
|
}
|
||||||
|
elsif ($i->{type} eq "hexline") {
|
||||||
|
$sensor = "hexline";
|
||||||
|
$def->{READINGS}{$sensor}{TIME} = $tm;
|
||||||
|
$def->{READINGS}{$sensor}{VAL} = $i->{current};
|
||||||
|
$def->{CHANGED}[$n++] = $sensor . ": " . $i->{current};;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
print "\nTRX_WEATHER: Unknown: ";
|
||||||
|
print "Type: ".$i->{type}.", ";
|
||||||
|
print "Value: ".$i->{current}."\n";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if ("$val" ne "") {
|
||||||
|
# remove heading and trailing space chars from $val
|
||||||
|
$val =~ s/^\s+|\s+$//g;
|
||||||
|
|
||||||
|
$def->{STATE} = $val;
|
||||||
|
$def->{TIME} = $tm;
|
||||||
|
$def->{CHANGED}[$n++] = $val;
|
||||||
|
}
|
||||||
|
|
||||||
|
#
|
||||||
|
#$def->{READINGS}{state}{TIME} = $tm;
|
||||||
|
#$def->{READINGS}{state}{VAL} = $val;
|
||||||
|
#$def->{CHANGED}[$n++] = "state: ".$val;
|
||||||
|
|
||||||
|
DoTrigger($name, undef);
|
||||||
|
|
||||||
|
return $val;
|
||||||
|
}
|
||||||
|
|
||||||
|
1;
|
||||||
@ -489,4 +489,8 @@
|
|||||||
- Sun Jan 29 2012 (Maz Rashid)
|
- Sun Jan 29 2012 (Maz Rashid)
|
||||||
- Improving 10_EIB.pm by introducing Get and interpreting received value according
|
- Improving 10_EIB.pm by introducing Get and interpreting received value according
|
||||||
to the selected model (based on datapoint types.)
|
to the selected model (based on datapoint types.)
|
||||||
- Introduced documentation for TUL / EIB modules.
|
- Introduced documentation for TUL / EIB modules.
|
||||||
|
|
||||||
|
- Fr Feb 24 2012 (Willi)
|
||||||
|
- New modules TRX for RFXCOM RFXtrx transceiver
|
||||||
|
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user