mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-02-25 03:44:52 +00:00
1474 lines
62 KiB
Perl
Executable File
1474 lines
62 KiB
Perl
Executable File
##############################################################################
|
|
# $Id$
|
|
# fhem Modul für PHC
|
|
#
|
|
# This file is part of fhem.
|
|
#
|
|
# Fhem 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.
|
|
#
|
|
# Fhem is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with fhem. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
# First version: 2017-02-11
|
|
#
|
|
# Todo / Ideas:
|
|
# =============
|
|
#
|
|
#
|
|
# Timer im STM von Fhem aus ändern?
|
|
# Dimer setzen - zuerst DimProz in Byte 1, dann Zeit in Byte 2 wie bei heller / dunkler dimmen kodiert (Max 160)
|
|
#
|
|
# command 01 (Ping), configure commands ...
|
|
#
|
|
# input validation for attrs (allowed EMD address)
|
|
# EMD Resend falls kein ACK
|
|
# Bei kaputten Frames nächstes Frame im Buffer suchen
|
|
#
|
|
# attr zum Steuern der Readings-Erzeugung
|
|
# setze alle Modul-Ausgänge in Readings mit Moduladr als Namen
|
|
# nur angegebenen Liste von Modulen in Readings setzen
|
|
# Namen für Readings überschreben mit eigenem attr (stärker als desc falls gesetzt)
|
|
# -Desc Readings erzeugen
|
|
#
|
|
# Parsen der ACK / Feedback Channelbits als Option? (Bei Umschalten wäre es aber nötig)
|
|
# Per Default auf eindeutige Befehle Readings setzen - Wert aus Command Hash (bei Ein / Aus, nicht bei Umschalten)
|
|
# Dim Feedback codes (ein / aus)
|
|
#
|
|
# What does not work:
|
|
# ===================
|
|
# AMD über Bus direkt ansprechen
|
|
# Problem: keine Unterscheidung im Protokoll zwischen Befehlen vom STM und solchen von Modulen. Erst ACK ist Unterscheid
|
|
# bei direktem Befehl meint STM dass es ein Feedback-Befeh ist. Die Acks überschneiden sich.
|
|
# -> direktes Ansprechen von AMDs scheint nicht sinnvoll.
|
|
# also Fhem als virtuelles EMD, STM soll dann AMDs ansprechen.
|
|
# AMD in Fhem simulieren?
|
|
# Fhem auf RPI viel zu langsam - erster Empfang enthält bereits 8 Resends vom STM bis Fhem überhaupt Befehl verarbeitet
|
|
# insgesamt kommen 63 Resends ...
|
|
#
|
|
|
|
package PHC;
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
use GPUtils qw(:all);
|
|
use Time::HiRes qw(gettimeofday);
|
|
use Encode qw(decode encode);
|
|
use SetExtensions qw(:all);
|
|
use DevIo;
|
|
use FHEM::HTTPMOD::Utils qw(:all);
|
|
|
|
use Exporter ('import');
|
|
our @EXPORT_OK = qw();
|
|
our %EXPORT_TAGS = (all => [@EXPORT_OK]);
|
|
|
|
|
|
BEGIN {
|
|
GP_Import( qw(
|
|
LoadModule
|
|
parseParams
|
|
CommandAttr
|
|
CommandDeleteAttr
|
|
addToDevAttrList
|
|
AttrVal
|
|
ReadingsVal
|
|
ReadingsTimestamp
|
|
readingsSingleUpdate
|
|
readingsBeginUpdate
|
|
readingsBulkUpdate
|
|
readingsEndUpdate
|
|
InternalVal
|
|
makeReadingName
|
|
DoTrigger
|
|
|
|
Log3
|
|
RemoveInternalTimer
|
|
InternalTimer
|
|
deviceEvents
|
|
EvalSpecials
|
|
AnalyzePerlCommand
|
|
CheckRegexp
|
|
|
|
gettimeofday
|
|
FmtDateTime
|
|
GetTimeSpec
|
|
fhemTimeLocal
|
|
time_str2num
|
|
rtrim
|
|
|
|
DevIo_OpenDev
|
|
DevIo_SimpleWrite
|
|
DevIo_SimpleRead
|
|
DevIo_CloseDev
|
|
SetExtensions
|
|
|
|
featurelevel
|
|
defs
|
|
modules
|
|
attr
|
|
init_done
|
|
));
|
|
|
|
GP_Export( qw(
|
|
Initialize
|
|
));
|
|
};
|
|
|
|
|
|
my $Version = '0.70 - 8.3.2022';
|
|
|
|
|
|
my %AdrType = (
|
|
0x00 => ['EMD'], # Class 0 starts at 0x00 (EMD, ...)
|
|
0x20 => ['MCC', 'UIM'], # Class 1 starts at 0x20 / 32 (UIM, MCC, ...)
|
|
0x40 => ['AMD', 'JRM'], # Class 2 starts at 0x40 / 64 (AMD, JRM)
|
|
0x60 => ['MFM'], # Class 3 starts at 0x60 / 96 (MFM, ...) FUI = MFM
|
|
0x80 => [], # Class 4 starts at 0x80 / 128 (?)
|
|
0xA0 => ['DIM'], # Class 5 starts at 0xA0 / 160 (DIM, ...)
|
|
0xC0 => [], # ?
|
|
0xE0 => ['CLK'] #
|
|
);
|
|
|
|
|
|
# number of bits to shift right for channel, &-Mask for function
|
|
my %CodeSplit = (
|
|
'EMD' => [4, 0x0F],
|
|
'MCC' => [4, 0x0F],
|
|
'UIM' => [4, 0x0F],
|
|
'AMD' => [5, 0x1F],
|
|
'JRM' => [5, 0x1F],
|
|
'MFM' => [4, 0x0F],
|
|
'DIM' => [5, 0x1F],
|
|
'CLK' => [4, 0x0F]
|
|
);
|
|
|
|
|
|
#
|
|
# Options:
|
|
# cbm Channel bits in command message
|
|
# cba Channel bits in ack
|
|
# cb2 2 Channel buts at the end of command message
|
|
# o use name for output channel
|
|
# i use name for input channel
|
|
# t1 time in data bytes 1+2
|
|
# t2 time in data bytes 2+3, 4+5 and 6+7 if present
|
|
# dt1 dim time in data byte 1 (coded) and data byte 2 is zero
|
|
# dt2 dim time in data byte 2 (coded) and dim value (0-255) in data byte 1
|
|
# p priority information in data byte 1
|
|
#
|
|
|
|
# format: 'Type Function Len Acklen' => ['Function Name', Options]
|
|
# Len=1 means just one byte for function/channel
|
|
# e.g. a Frame with Adr, 81/01, Fkt/Chan CRC
|
|
|
|
my %functions = (
|
|
'EMD02+01' => ['Ein > 0', 'i'], # EMD, Function 2, Len flexible, AckLen 1
|
|
'EMD03+01' => ['Aus < 1', 'i'],
|
|
'EMD04+01' => ['Ein > 1', 'i'],
|
|
'EMD05+01' => ['Aus > 1', 'i'],
|
|
'EMD06+01' => ['Ein > 2', 'i'],
|
|
'EMD07+01' => ['Aus', 'i'],
|
|
|
|
'EMD020103' => ['LED_Ein', 'o'],
|
|
'EMD030103' => ['LED_Aus', 'o'],
|
|
|
|
'AMD010102' => ['Ping', 'cba'],
|
|
'AMD020102' => ['Ein', 'cba', 'o'],
|
|
'AMD030102' => ['Aus', 'cba', 'o'],
|
|
'AMD040102' => ['An Lock', 'cba', 'o'],
|
|
'AMD050102' => ['Aus Lock', 'cba', 'o'],
|
|
'AMD060102' => ['Umschalten', 'cba', 'o'],
|
|
'AMD070102' => ['Unlock', 'cba', 'o'],
|
|
'AMD080302' => ['An verzögert', 'cba', 't1', 'o'],
|
|
'AMD090302' => ['Aus verzögert', 'cba', 't1', 'o'],
|
|
'AMD100302' => ['An mit Timer', 'cba', 't1', 'o'],
|
|
'AMD110302' => ['Aus mit Timer', 'cba', 't1', 'o'],
|
|
'AMD120302' => ['Umschalten verzögert', 'cba', 't1', 'o'],
|
|
'AMD130302' => ['Umschalten mit Timer', 'cba', 't1', 'o'],
|
|
'AMD140102' => ['Lock', 'cba', 'o'],
|
|
'AMD150102' => ['Lock for time running', 'cba', 'o'],
|
|
'AMD160302' => ['Timer Addieren', 'cba', 't1', 'o'],
|
|
'AMD170302' => ['Timer setzen', 'cba', 't1', 'o'],
|
|
'AMD180102' => ['Timer cancel', 'cba', 'o'],
|
|
|
|
'AMD020201' => ['FB_Ein', 'cbm'],
|
|
'AMD030201' => ['FB_Aus', 'cbm'],
|
|
'AMD290201' => ['FB_Timer_Aus', 'cbm'], # kommt nach F10 wenn Zeit abgelaufen ist todo: check aus mit timer feedback?
|
|
|
|
'JRM020202' => ['Stop', 'o'],
|
|
'JRM030402' => ['Umschalten heben stop', 'p', 't2', 'o'],
|
|
'JRM040402' => ['Umschalten senken stop', 'p', 't2', 'o'],
|
|
'JRM050402' => ['Heben', 'p', 't2', 'o'],
|
|
'JRM060402' => ['Senken', 'p', 't2', 'o'],
|
|
'JRM070402' => ['Flip auf', 'p', 't2', 'o'],
|
|
'JRM080402' => ['Flip ab', 'p', 't2', 'o'],
|
|
|
|
'JRM030201' => ['FB_Senken_Ein', 'cbm'],
|
|
'JRM040201' => ['FB_Heben_Aus', 'cbm'],
|
|
'JRM050201' => ['FB_Senken_Aus', 'cbm'],
|
|
|
|
'JRM060201' => ['FB_Timer_Ein', 'cbm'],
|
|
'JRM060301' => ['FB_Timer_Ein', 'cbm'],
|
|
|
|
'JRM070201' => ['FB_Timer_Cancel', 'cbm'],
|
|
'JRM080201' => ['FB_Timer_Aus', 'cbm'],
|
|
|
|
'JRM090202' => ['Prio lock', 'p'],
|
|
'JRM100202' => ['Prio unlock', 'p'],
|
|
'JRM11' => ['Lernen an'], # uses different communication
|
|
'JRM12' => ['Lernen aus'],
|
|
'JRM130202' => ['Prio setzen', 'p'],
|
|
'JRM140202' => ['Prio löschen', 'p'],
|
|
'JRM150602' => ['Sensor heben', 'p', 't2', 'o'],
|
|
'JRM160802' => ['Sensor heben flip', 'p', 't2', 'o'],
|
|
'JRM170602' => ['Sensor senken', 'p', 't2', 'o'],
|
|
'JRM180802' => ['Sensor senken flip', 'p', 't2', 'o'],
|
|
'JRM190302' => ['Zeitmessung verzögert an', 't1', 'o'],
|
|
'JRM200302' => ['Zeitmessung verzögert aus', 't1', 'o'],
|
|
'JRM210302' => ['Zeitmessung an mit Timer', 't1', 'o'],
|
|
'JRM220102' => ['Zeitmessung cancel', 'o'],
|
|
|
|
'DIM020102' => ['Ein Max mit Memory', 'cb2', 'o'],
|
|
'DIM030102' => ['Ein Max ohne Memory', 'cb2', 'o'],
|
|
'DIM040102' => ['Aus', 'cb2', 'o'],
|
|
'DIM050102' => ['Umschalten Max mit Memory', 'cb2', 'o'],
|
|
'DIM060102' => ['Umschalten Max ohne Memory', 'cb2', 'o'],
|
|
'DIM070302' => ['Dimmen Gegenrichtung', 'cb2', 'dt1', 'o'],
|
|
'DIM080302' => ['Heller Dimmen', 'cb2', 'dt1', 'o'],
|
|
'DIM090302' => ['Dunkler Dimmen', 'cb2', 'dt1', 'o'],
|
|
'DIM100102' => ['Speichern Memory', 'cb2', 'o'],
|
|
'DIM110102' => ['Umschalten Memory', 'cb2', 'o'],
|
|
'DIM120102' => ['Ein Memory', 'cb2', 'o'],
|
|
'DIM130102' => ['Speichern DIA1', 'cb2'],
|
|
'DIM140102' => ['Umschalten DIA1', 'cb2'],
|
|
'DIM150102' => ['Ein DIA1', 'cb2'],
|
|
'DIM160102' => ['Speichern DIA2', 'cb2'],
|
|
'DIM170102' => ['Umschalten DIA2', 'cb2'],
|
|
'DIM170302' => ['Umschalten DIA2', 'cb2'], # mcp reported that both variants can be observed
|
|
'DIM180102' => ['Ein DIA2', 'cb2'],
|
|
'DIM190102' => ['Speichern DIA3', 'cb2'],
|
|
'DIM200102' => ['Umschalten DIA3', 'cb2'],
|
|
'DIM210102' => ['Ein DIA3', 'cb2'],
|
|
'DIM220302' => ['Dimmwert und Zeit setzen', 'cb2', 'dt2'],
|
|
|
|
'DIM020201' => ['FB_Ein'],
|
|
'DIM030201' => ['FB_Aus'],
|
|
|
|
'MFM020103' => ['Ein', 'o'],
|
|
'MFM030103' => ['Aus', 'o'],
|
|
'MFM040103' => ['Umschalten', 'o'],
|
|
'MFM050103' => ['Ein verzögert', 'o'],
|
|
'MFM060103' => ['Aus verzögert', 'o'],
|
|
'MFM070103' => ['Ein mit Timer', 'o'],
|
|
'MFM080103' => ['Aus mit Timer', 'o'],
|
|
'MFM090103' => ['Dimmen in Gegenrichtung', 'o'],
|
|
'MFM100103' => ['Heller Dimmen', 'o'],
|
|
'MFM110103' => ['Dunkler Dimmen', 'o'],
|
|
'MFM120103' => ['Dimmwert und Zeit setzen', 'o'],
|
|
'MFM130103' => ['Rollade heben', 'o'],
|
|
'MFM140103' => ['Rollade senken', 'o'],
|
|
'MFM150103' => ['Aktion abbrechen', 'o'],
|
|
|
|
'MFM020101' => ['Taste O Ein > 0', 'i'],
|
|
'MFM030101' => ['Taste I Ein > 0', 'i'],
|
|
'MFM040101' => ['Taste O Aus', 'i'],
|
|
'MFM050101' => ['Taste I Aus', 'i'],
|
|
'MFM060101' => ['unknown06'],
|
|
'MFM070101' => ['unknown07'],
|
|
'MFM080101' => ['unknown08'],
|
|
'MFM090101' => ['unknown09'],
|
|
'MFM100101' => ['Taste O Ein > 1', 'i'],
|
|
'MFM110101' => ['Taste I Ein > 1', 'i'],
|
|
'MFM130301' => ['unknown13-3-1'],
|
|
|
|
'UIM020101' => ['On/Off Ein', 'i'],
|
|
'UIM040101' => ['Auf Ein', 'i'],
|
|
'UIM060101' => ['Ab Ein', 'i'],
|
|
|
|
'MCC020101' => ['Ein > 0', 'i'],
|
|
'MCC020103' => ['LED Ein', 'o', 'cba'],
|
|
'MCC030103' => ['LED Aus', 'o', 'cba'],
|
|
'MCC090103' => ['LED Blink'],
|
|
|
|
'CLK03' => ['Clock Request']
|
|
);
|
|
|
|
|
|
|
|
#####################################
|
|
# called when module is loaded
|
|
sub Initialize {
|
|
my $hash = shift;
|
|
|
|
$hash->{ReadFn} = \&ReadFn;
|
|
$hash->{ReadyFn} = \&ReadyFn;
|
|
$hash->{DefFn} = \&DefineFn;
|
|
$hash->{UndefFn} = \&UndefFn;
|
|
$hash->{SetFn} = \&SetFn;
|
|
$hash->{GetFn} = \&GetFn;
|
|
$hash->{AttrFn} = \&AttrFn;
|
|
|
|
$hash->{AttrList}= "do_not_notify:1,0 " .
|
|
#"timeout " .
|
|
"silentReconnect " .
|
|
"sendEcho:1,0 " .
|
|
"module[0-9]+description " .
|
|
"module[0-9]+type " .
|
|
"channel(EMD|AMD|JRM|DIM|UIM|MCC|MFM)[0-9]+[io]?[0-9]+description " .
|
|
"channel(EMD|AMD|JRM|DIM|UIM|MCC|MFM)[0-9]+[o]?[0-9]+set " .
|
|
"virtEMD[0-9]+C[0-9]+Name " . # virtual emd channel for set
|
|
"EMDReadings " .
|
|
'HTTPMOD ' .
|
|
'STM_ADR ' .
|
|
"BusEvents:none,simple,long " .
|
|
$main::readingFnAttributes;
|
|
|
|
LoadModule "HTTPMOD";
|
|
return;
|
|
}
|
|
|
|
|
|
############################################
|
|
# called by Fhem to define a device as PHC
|
|
sub DefineFn {
|
|
my $hash = shift; # reference to device hash
|
|
my $def = shift; # definition string
|
|
my @a = split("[ \t]+", $def); # split definition string
|
|
my ($name, $PHC, $dev) = @a; # device name, "PHC", RS485 interface path
|
|
|
|
return "wrong syntax: define <name> PHC [devicename]" if(@a < 3);
|
|
|
|
eval {use Digest::CRC qw(crc crc32 crc16 crcccitt)};
|
|
if($@) {
|
|
return "Please install the Perl Digest Library (apt-get install libdigest-crc-perl) - error was $@";
|
|
}
|
|
|
|
$hash->{BUSY} = 0;
|
|
$hash->{EXPECT} = '';
|
|
$hash->{ModuleVersion} = $Version;
|
|
|
|
return if ($dev eq 'none');
|
|
|
|
if ($dev !~ /.+@([0-9]+)/) {
|
|
$dev .= '@19200,8,N,2'; # default baud rate
|
|
} else {
|
|
Log3 $name, 3, "$name: Warning: connection speed $1 is probably wrong for the PHC bus. Default is 19200,8,N,2"
|
|
if ($1 != 19200);
|
|
}
|
|
|
|
$hash->{DeviceName} = $dev;
|
|
$hash->{devioLoglevel} = (AttrVal($name, "silentReconnect", 0) ? 4 : 3);
|
|
|
|
DevIo_CloseDev($hash);
|
|
my $ret = DevIo_OpenDev($hash, 0, 0);
|
|
return $ret;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# called hen Fhem deletes a device
|
|
sub UndefFn {
|
|
my $hash = shift;
|
|
my $arg = shift;
|
|
my $name = $hash->{NAME};
|
|
DevIo_CloseDev($hash);
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# Attr command
|
|
sub AttrFn {
|
|
my $cmd = shift; # 'set' or 'del'
|
|
my $name = shift; # device name
|
|
my $aName = shift; # attribute name
|
|
my $aVal = shift; # attribute value
|
|
my $hash = $defs{$name}; # reference to the device hash
|
|
|
|
Log3 $name, 5, "$name: Attr called with $cmd $name $aName $aVal";
|
|
if ($cmd eq 'set') {
|
|
if ($aName =~ m{\A virtEMD ([0-9]+) C ([0-9]+) Name \z}xms) {
|
|
my $modAdr = $1;
|
|
my $cnlAdr = $2;
|
|
if ($modAdr >= 32) {
|
|
return "illegal EMD module address $modAdr - address needs to be < 32 and it must not be used on the bus";
|
|
}
|
|
if ($cnlAdr >= 16) {
|
|
return "illegal EMD channel address $cnlAdr - address needs to be < 16";
|
|
}
|
|
my @virtEMDList = grep { m{\A virtEMD [0-9]+ C [0-9]+ Name \z}xms} keys %{$attr{$name}};
|
|
foreach my $attrName (@virtEMDList) {
|
|
if ($aVal eq $attr{$name}{$attrName}) { # ist es der im konkreten Attr verwendete Name?
|
|
if ($attrName ne $aName) {
|
|
return "Name $aVal is already used for virtual EMD $attrName";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# get command
|
|
sub GetFn {
|
|
my @getValArr = @_; # rest is optional values
|
|
my $hash = shift @getValArr; # reference to device hash
|
|
my $name = shift @getValArr; # device name
|
|
my $getName = shift @getValArr; # get option name
|
|
my $getVal = join(' ', @getValArr); # optional value after get name
|
|
|
|
return "\"get $name\" needs at least one argument" if (!$getName);
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# switch toggle
|
|
sub DoToggle {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $modAdr = shift; # PHC module address
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
|
|
if ($hash->{Toggle}{$modAdr} && $hash->{Toggle}{$modAdr} eq 's') {
|
|
$hash->{Toggle}{$modAdr} = 'c';
|
|
Log3 $name, 3, "$name: toggle for module $modAdr was set and will now be cleared";
|
|
} elsif ($hash->{Toggle}{$modAdr} && $hash->{Toggle}{$modAdr} eq 'c') {
|
|
$hash->{Toggle}{$modAdr} = 's';
|
|
Log3 $name, 5, "$name: toggle for module $modAdr was cleared and will now be set";
|
|
} else {
|
|
$hash->{Toggle}{$modAdr} = 'c';
|
|
Log3 $name, 3, "$name: toggle for module $modAdr was unknown and will now be cleared";
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################################
|
|
# send PHC command
|
|
sub SendFrame {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $modAdr = shift; # PHC module address
|
|
my $hexCmd = shift; # combined function and channel as hex string
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
|
|
Log3 $name, 5, "$name: SendFrame called with hexCmd $hexCmd for module $modAdr";
|
|
DoToggle($hash, $modAdr);
|
|
|
|
my $lUTog = (length ($hexCmd) / 2) | (($hash->{Toggle}{$modAdr} eq 's' ? 1 : 0) << 7);
|
|
my $frame = pack ('CCH*', $modAdr, $lUTog, $hexCmd);
|
|
my $crc = pack ('v', crc($frame, 16, 0xffff, 0xffff, 1, 0x1021, 1, 0));
|
|
$frame = $frame . $crc;
|
|
|
|
Log3 $name, 5, "$name: sends " . unpack ('H*', $frame);
|
|
|
|
if (!AttrVal($name, "sendEcho", 0)) {
|
|
my $now = gettimeofday();
|
|
$hash->{helper}{buffer} .= $frame;
|
|
$hash->{helper}{lastRead} = $now;
|
|
}
|
|
DevIo_SimpleWrite($hash, $frame, 0);
|
|
return;
|
|
}
|
|
|
|
|
|
########################################################
|
|
# find PHC function in function hash
|
|
# to be called from DoEMD and setFn (new XMLRPC stuff)
|
|
sub FindFunction {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $fName = shift; # input function name
|
|
my $mType = shift // 'EMD';
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
my $function = 0;
|
|
$fName = '^' . lc($fName) . '$'; # input function name to be compared as regex
|
|
$fName =~ s/(\s|_| |(\\xc2\\xa0))+/_*/g; # function name with spaces as \s*
|
|
|
|
FuncLOOP: # look for entry in PHC functions parse information hash (ModuleFuncLenAcklen => Name, Options)
|
|
foreach my $hkey (grep {m/^$mType/i} keys %functions) {
|
|
#Log3 $name, 5, "$name: FindFunction hkey $hkey";
|
|
my $fn = lc $functions{$hkey}[0]; # function name in hash
|
|
#Log3 $name, 5, "$name: FindFunction fn >$fn<";
|
|
$fn =~ s/ //g; # function name without spaces
|
|
$fn = $1 if ($fn =~ /(.*),.*/); # strip anything in the name after a komma ... todo: is this necessary?
|
|
Log3 $name, 5, "$name: FindFunction regex compare >$fn< to >$fName< ";
|
|
if ($fn =~ $fName) { # is this the function name passed?
|
|
Log3 $name, 4, "$name: FindFunction found function $fn as $hkey";
|
|
return $hkey;
|
|
}
|
|
}
|
|
Log3 $name, 4, "$name: FindFunction did not find function for $fName on $mType" if (!$function);
|
|
return;
|
|
}
|
|
|
|
|
|
########################################################
|
|
# find possible PHC output functions per module type
|
|
sub FindOutFunctions {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $mType = shift;
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
my %fList;
|
|
|
|
foreach my $hkey (grep {m/^$mType/i} keys %functions) {
|
|
my @opts = @{$functions{$hkey}};
|
|
#Log3 $name, 5, "$name: FindOutFunctions: hkey $hkey, opts " . join (' ', @opts);
|
|
my $fn = lc $functions{$hkey}[0]; # function name in hash
|
|
$fn =~ s/\s/ /g; # convert spaces for fhemweb
|
|
#$fn =~ s/ /_/g; # function name without spaces
|
|
if (grep {/^o$/} @opts) {
|
|
$fList{$fn} = 1;
|
|
#Log3 $name, 5, "$name: FindOutFunctions: match fn >$fn<";
|
|
}
|
|
}
|
|
my @functions = keys %fList;
|
|
Log3 $name, 5, "$name: FindOutFunctions: did find functions " . join (' ', @functions);
|
|
return @functions;
|
|
}
|
|
|
|
|
|
#####################################################
|
|
# EMD aktion (mod, channel, function) simulieren
|
|
# aufgerufen von set
|
|
sub DoEMD {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $modAdr = shift; # PHC module address
|
|
my $channel = shift; # channel number in module
|
|
my $fName = shift; # input function name
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
|
|
Log3 $name, 3, "$name: DoEMD called for module $modAdr, channel $channel, function $fName";
|
|
my $hKey = FindFunction($hash, $fName, 'EMD');
|
|
return "function $fName not found" if (!$hKey);
|
|
|
|
if ($hKey !~ /EMD([0-9][0-9]).*/i) {
|
|
return "can not get function number for $hKey";
|
|
}
|
|
my $function = $1;
|
|
my $code = ($function + ($channel << 4)); # EMD commands are code without aditional data, len is always 1
|
|
my $hexCmd = unpack ('H2', pack ('C', $code));
|
|
Log3 $name, 5, "$name: DoCmd: channel $channel, function $function => $code / $hexCmd";
|
|
|
|
SendFrame($hash, $modAdr, $hexCmd);
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################################
|
|
# import PHC channel descriptions
|
|
sub DoImport {
|
|
my $hash = shift;
|
|
my $setVal = shift;
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
|
|
my $iFile;
|
|
if (!open($iFile, "<", $setVal)) {
|
|
Log3 $name, 3, "$name: Cannot open template file $setVal";
|
|
return "Cannot open template file $setVal";
|
|
};
|
|
my $mType = 'unknown';
|
|
my $mAdr = 'unknown';
|
|
my $aAdr = 'unknown';
|
|
my $mName = 'unknown';
|
|
my $mDisp = 'unknown';
|
|
my $cType = 'i';
|
|
my $encoding = '';
|
|
my ($key, $cAdr, $cName);
|
|
while (<$iFile>) {
|
|
my $line = $_;
|
|
Log3 $name, 5, "$name: import read line $line";
|
|
if ($line =~ /xml version.* encoding="([^\"]+)"/) {
|
|
$encoding = $1;
|
|
Log3 $name, 5, "$name: import encoding is $encoding";
|
|
next;
|
|
}
|
|
$line = decode($encoding, $line) if ($encoding);
|
|
|
|
if ($line =~ /^\s*<MOD\s/) {
|
|
if ($line =~ /\sadr="([0-9]+)"\s/) {
|
|
$aAdr = sprintf('%03d', $1);
|
|
$mAdr = sprintf('%02d', $1 & 0x1f);
|
|
}
|
|
if ($line =~ /\sname="([^"]+)"/) {
|
|
$mName = $1;
|
|
$mType = substr($mName, 0, 3);
|
|
}
|
|
if ($line =~ /\sdisplay="([^"]+)"/) {
|
|
$mDisp = encode ('UTF-8', $1);
|
|
}
|
|
CommandAttr(undef, "$name module${aAdr}description $mDisp");
|
|
CommandAttr(undef, "$name module${aAdr}type $mType");
|
|
} elsif ($line =~ /<OUT>/) {
|
|
$cType = 'o';
|
|
} elsif ($line =~ /<IN>/) {
|
|
$cType = 'i';
|
|
} elsif ($line =~ /^\s*<CHA\s/) {
|
|
if ($line =~ /\sadr="([0-9]+)"/) {
|
|
my $rAdr = $1 & 0x1f;
|
|
$cAdr = sprintf('%02d', $rAdr);
|
|
}
|
|
if ($line =~ /\sname="([^"]+)"/) {
|
|
$cName = encode ('UTF-8', $1);
|
|
}
|
|
$key = $mType . $mAdr . $cType . $cAdr;
|
|
CommandAttr(undef, "$name channel${key}description $cName");
|
|
}
|
|
}
|
|
close $iFile;
|
|
return;
|
|
}
|
|
|
|
|
|
###################################################################
|
|
# call XML-RPC service via HTTPMOD
|
|
sub XMLRPC {
|
|
my @args = @_;
|
|
my $hash = shift @args;
|
|
my $service = shift @args;
|
|
my $name = $hash->{NAME};
|
|
my $hName = AttrVal($name, 'HTTPMOD', ''); # which HTTPMOD to use? (url defined there)
|
|
my $data = "<methodCall> <methodName>$service</methodName> <params>";
|
|
foreach my $arg (@args) {
|
|
$data .= "<param><value><int>$arg</int></value></param>"; # for now only a list of ints
|
|
}
|
|
$data .= "</params> </methodCall>";
|
|
Log3 $name, 4, "$name: XMLRPC called with $service and " . join (',', map {sprintf("0x%02X", $_)} @args);
|
|
Log3 $name, 5, "$name: XMLRPC data = $data";
|
|
if ($hName && $defs{$hName} && $defs{$hName}{TYPE} && $defs{$hName}{TYPE} eq "HTTPMOD") {
|
|
HTTPMOD::AddToSendQueue($defs{$hName}, {'url' => $defs{$hName}{MainURL}, 'data' => $data, 'type' => 'external'});
|
|
} else {
|
|
Log3 $name, 3, "$name: XMLRPC does not have valid HTTPMOD device. Please set attr HTTPMOD to a device configured to your STM with port 6680";
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
#################################################
|
|
# set an output via xmlrpc
|
|
sub DoChannelSet {
|
|
my $hash = shift;
|
|
my $modType = shift;
|
|
my $modAdr = shift;
|
|
my $modChannel = shift;
|
|
my $setVal = shift;
|
|
my $name = $hash->{NAME};
|
|
|
|
my $adrOffset = 0;
|
|
my $stmAdr = AttrVal($name, 'STM_ADR', 0);
|
|
my($args, $keys) = parseParams(lc($setVal));
|
|
my $fName = join ' ', @{$args};
|
|
|
|
OFFLOOP:
|
|
foreach my $off (keys %AdrType) {
|
|
if (grep {/^$modType$/i} @{$AdrType{$off}}) {
|
|
$adrOffset = $off;
|
|
last OFFLOOP
|
|
}
|
|
}
|
|
$modAdr += $adrOffset; # absolute address
|
|
|
|
Log3 $name, 5, "$name: DoChannelSet called for direct output on $modType (offset $adrOffset), adr $modAdr, ch $modChannel, $fName";
|
|
my $hKey = FindFunction($hash, $fName, $modType);
|
|
return "function $fName not found" if (!$hKey);
|
|
|
|
if ($hKey !~ /$modType([0-9][0-9]).*/i) {
|
|
return "can not get function number for $hKey";
|
|
}
|
|
my $function = $1;
|
|
|
|
my $split = $CodeSplit{uc($modType)}; # get number of bits to combine channel and function
|
|
return "unknown module type $modType - can not use splitCode" if (!$split);
|
|
my $cmdByte = ($modChannel << $split->[0]) + $function;
|
|
|
|
my @parseOpts = @{$functions{$hKey}};
|
|
Log3 $name, 5, "$name: function def = " . join ",", @parseOpts;
|
|
|
|
shift @parseOpts;
|
|
my %opts;
|
|
foreach (@parseOpts) {$opts{$_} = 1};
|
|
my @cmdOpts;
|
|
|
|
if ($opts{'p'}) {
|
|
my $prio = $keys->{prio} // 3; # default prio 3
|
|
return "illegal prio $prio" if ($prio > 7);
|
|
$prio |= 0x40 if ($keys->{set}); # set priority?
|
|
push @cmdOpts, $prio;
|
|
}
|
|
if ($opts{'t1'}||$opts{'t2'}) {
|
|
my $time = $keys->{time} // 600; # 60 secs as default
|
|
return "illegal time $time" if ($time > 3000);
|
|
my $t1 = int($time / 256);
|
|
my $t2 = int($time) % 256;
|
|
push @cmdOpts, $t2; # low byte
|
|
push @cmdOpts, $t1; # high byte
|
|
}
|
|
if ($opts{'dt1'}) {
|
|
my $time = $keys->{time} // 5; # 5 secs as default
|
|
return "illegal time $time" if ($time > 160);
|
|
my $t1 = int($time * 25 / 16);
|
|
push @cmdOpts, $t1;
|
|
push @cmdOpts, 0;
|
|
}
|
|
if ($opts{'dt2'}) {
|
|
my $value = $keys->{value} // 128; # 128 as default (50%)
|
|
my $time = $keys->{time} // 5; # 5 secs as default
|
|
return "illegal time $time" if ($time > 160);
|
|
my $t1 = int($time * 25 / 16);
|
|
push @cmdOpts, $value;
|
|
push @cmdOpts, $t1;
|
|
}
|
|
|
|
XMLRPC($hash, 'service.stm.sendTelegram', $stmAdr, $modAdr, $cmdByte, @cmdOpts);
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# set comand
|
|
sub SetFn {
|
|
my @setValArr = @_; # remainder is set values
|
|
my $hash = shift @setValArr; # reference to Fhem device hash
|
|
my $name = shift @setValArr; # Fhem device name
|
|
my $setName = shift @setValArr; # name of the set option
|
|
my $setVal = join(' ', @setValArr); # set values as one string
|
|
|
|
Log3 $name, 5, "$name: SetFn called from " . FhemCaller() . " with $setName and $setVal";
|
|
|
|
return "\"set $name\" needs at least one argument" if(!$setName);
|
|
|
|
if ($setName eq 'importChannelList') {
|
|
if (!$setVal) {
|
|
return 'please specify a filename';
|
|
}
|
|
return DoImport($hash, $setVal);
|
|
}
|
|
elsif ($setName eq 'emd') {
|
|
my @arg = @setValArr;
|
|
shift @arg;
|
|
shift @arg;
|
|
my $fName = lc join(' ', @arg);
|
|
return DoEMD($hash, $setValArr[0], $setValArr[1], $fName);
|
|
}
|
|
elsif ($setName eq "sendRaw") {
|
|
my $modAdr = unpack ('H2', $setValArr[0]);
|
|
my $hexCmd = $setValArr[1];
|
|
SendFrame($hash, $modAdr, $hexCmd);
|
|
}
|
|
elsif ($setName =~ m{ (EMD|MCC|UIM|AMD|JRM|MFM|DIM) ([\d]+) o ([\d]+) }xmsi) {
|
|
my $modType = $1;
|
|
my $modAdr = $2;
|
|
my $modChannel = $3;
|
|
return DoChannelSet($hash, $1, $2, $3, $setVal);
|
|
}
|
|
else {
|
|
my @ChannelSetList = grep { m{channel (EMD|AMD|JRM|DIM|UIM|MCC|MFM) [0-9]+ [o]? [0-9]+ set}xms } keys %{$attr{$name}};
|
|
my @setModHintList;
|
|
Log3 $name, 5, "$name: check setName $setName against attrs " . join ",", @ChannelSetList if ($setName ne '?');
|
|
foreach my $setAttr (@ChannelSetList) {
|
|
if ($setAttr =~ m{channel (EMD|AMD|JRM|DIM|UIM|MCC|MFM) ([0-9]+) ([o]?) ([0-9]+) set}xms) {
|
|
my $modType = $1;
|
|
my $modAdr = $2;
|
|
my $o = $3;
|
|
my $chAdr = $4;
|
|
my $aName = "channel$modType$modAdr$o$chAdr" . 'description';
|
|
my $aVal = SanitizeReadingName(lc($attr{$name}{$aName}));
|
|
my $nameCmp = SanitizeReadingName(lc($setName));
|
|
$nameCmp =~ s/ //g; # channel name without spaces
|
|
Log3 $name, 5, "$name: compare $nameCmp with $aVal" if ($setName ne '?');
|
|
if ($nameCmp eq $aVal) {
|
|
return DoChannelSet($hash, $modType, $modAdr, $chAdr, $setVal);
|
|
}
|
|
push @setModHintList, $aVal . ':' . join (',', FindOutFunctions($hash, $modType));
|
|
}
|
|
}
|
|
my @virtEMDList = grep { m{virtEMD [0-9]+ C [0-9]+ Name}xms } keys %{$attr{$name}};
|
|
foreach my $aName (@virtEMDList) {
|
|
if (lc($setName) eq lc($attr{$name}{$aName})) { # ist es der im konkreten Set verwendete setName?
|
|
if ($aName =~ m{virtEMD ([0-9]+) C ([0-9]+) Name}xms) {
|
|
return DoEMD($hash, $1, $2, $setVal);
|
|
}
|
|
}
|
|
}
|
|
# todo: also take input functions from functions hash
|
|
my $hints = "Unknown argument $setName, choose one of importChannelList sendRaw amd.*:ein,aus,umschalten" .
|
|
' ' . join (' ', map { $attr{$name}{$_} . ':ein>0,ein>1,ein>2,aus,aus<1,aus>1' } @virtEMDList ) .
|
|
' ' . join (' ', @setModHintList);
|
|
return $hints;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
###############################################################################
|
|
# Called from ParseCommands
|
|
# find out type of module at $command->{ADR}
|
|
# then split the code field into channel and function
|
|
# then search in functions hash for matching function and details / options
|
|
# set keys in command hash: MTYPE, CHANNEL, FUNCTION, FNAME, PARSEOPTS, CTYPE
|
|
#
|
|
sub ParsePHCCode {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $command = shift; # reference to command hash containing ADR and CMD
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
|
|
my $fAdr = sprintf('%03d', $command->{ADR}); # formatted abs module adr for attr lookup (mod type)
|
|
my @typeArr = split (',', AttrVal($name, "module${fAdr}type", "")); # potential types from attr
|
|
my $typeAttrLen = @typeArr; # number of potential types in attr
|
|
@typeArr = @{$AdrType{$command->{ADR} & 0xE0}} if (!@typeArr); # fallback to types from AdrType hash
|
|
my $mType = $typeArr[0]; # first option for split (same for all options)
|
|
|
|
#Log3 $name, 5, "$name: ParseCode called, Adr $fAdr, typeArr = @typeArr, code " . sprintf ('x%02X', $command->{CODE});
|
|
#Log3 $name, 5, "$name: ParseCode data = @{$command->{DATA}}";
|
|
#Log3 $name, 5, "$name: ParseCode ackdata = @{$command->{ACKDATA}}";
|
|
|
|
return 'unknown module type' if (!$mType);
|
|
$command->{MTYPE} = $mType; # first idea unless we find a fit later
|
|
|
|
# splitting and therefore channel and function are the same within one address class
|
|
# so they are ok to calculate here regardless of the exact module type identified later
|
|
my ($channel, $function) = SplitPHCCode($hash, $mType, $command->{CODE});
|
|
$command->{CHANNEL} = $channel;
|
|
$command->{FUNCTION} = $function;
|
|
|
|
my $key1 = sprintf('%02d', $function); # formatted function number
|
|
my $key2 = sprintf('%02d', $command->{LEN}); # formatted LEN
|
|
my $key3 = sprintf('%02d', $command->{ACKLEN}); # formatted ACKLEN
|
|
my $wldk = '+';
|
|
my @keys = ("$mType$key1$key2$key3", "$mType$key1$wldk$key3", "$mType$key1$key2", "$mType$key1");
|
|
|
|
Log3 $name, 5, "$name: ParseCode for Adr $fAdr checks typelist @typeArr against" .
|
|
" Fkt=" . sprintf ('x%02X', $function) . " Ch=" . sprintf ('x%02X', $channel) .
|
|
" Len=$command->{LEN}, ackLen=$command->{ACKLEN}";
|
|
|
|
my $bestFit = 0; # any fit of key 3, 2 or 1 is better than 0
|
|
TYPELOOP:
|
|
foreach my $mTypePot (@typeArr) {
|
|
#Log3 $name, 5, "$name: ParseCode checks if type of module at $fAdr can be $mTypePot";
|
|
|
|
# does this module type match better than a previously tested type?
|
|
my $idx = 4; # four levels of abstraction in the functions hash
|
|
FUNCLOOP:
|
|
foreach my $key (@keys) { # four keys, one for each abstraction
|
|
if ($functions{$key}) {
|
|
#Log3 $name, 5, "$name: match: $key";
|
|
if ($idx > $bestFit) { # longer = better matching type found
|
|
$bestFit = $idx; # save for next type
|
|
my @parseOpts = @{$functions{$key}};
|
|
$command->{MTYPE} = $mTypePot;
|
|
$command->{FNAME} = shift @parseOpts;
|
|
foreach (@parseOpts) {$command->{PARSEOPTS}{$_} = 1};
|
|
Log3 $name, 5, "$name: ParseCode match $key / $command->{FNAME} " . join (',', @parseOpts);
|
|
}
|
|
last FUNCLOOP; # first match is the best for this potential type
|
|
}
|
|
if (!$idx) { # this was the last try for this type with $idx=0, $key=$mTypePot$key1
|
|
@typeArr = grep {!/$mTypePot/} @typeArr; # module type is not an option any more
|
|
Log3 $name, 5, "$name: ParseCode could not match to $mTypePot, delete this option";
|
|
last FUNCLOOP; # not really necessary because at idx=0 FUNCLOOP is through anyway -> next TYPELOOP
|
|
}
|
|
$idx--;
|
|
}
|
|
}
|
|
Log3 $name, 4, "$name: ParseCode typelist after matching is @typeArr" if (@typeArr > 1);
|
|
|
|
return 'no parse info' if (!$command->{FNAME});
|
|
|
|
$command->{CTYPE} = ($command->{PARSEOPTS}{'i'} ? 'i' : 'o');
|
|
|
|
if (!$typeAttrLen || (scalar(@typeArr) >= 1 && scalar(@typeArr) < $typeAttrLen)) {
|
|
# no moduleType attr so far or we could eliminate an option -> set more specific new attr
|
|
CommandAttr(undef, "$name module${fAdr}type " . join (',', @typeArr));
|
|
#Log3 $name, 4, "$name: set attr $name module${fAdr}type " . join (',', @typeArr);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# Called from ParseCommands
|
|
sub ParseOptions {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $command = shift; # reference to command hash containing ADR and CMD
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
my $dLen = @{$command->{DATA}}; # length of Data
|
|
|
|
if ($command->{PARSEOPTS}{'p'}) { # priority in data[1]
|
|
$command->{PRIO} = unpack ('b6', pack ('C', $command->{DATA}[1] & 0x3F));
|
|
$command->{PSET} = $command->{DATA}[1] & 0x40;
|
|
}
|
|
|
|
if ($command->{PARSEOPTS}{'t1'}) { # time in data[1] / data[2] (JRM)
|
|
$command->{TIME1} = $command->{DATA}[1] + ($command->{DATA}[2] << 8) if ($dLen > 2);
|
|
}
|
|
|
|
if ($command->{PARSEOPTS}{'t2'}) { # times in data[2/3] and data[4/5] ... if existant (JRM)
|
|
$command->{TIME1} = $command->{DATA}[2] + ($command->{DATA}[3] << 8) if ($dLen > 3);
|
|
$command->{TIME2} = $command->{DATA}[4] + ($command->{DATA}[5] << 8) if ($dLen > 5);
|
|
$command->{TIME3} = $command->{DATA}[6] + ($command->{DATA}[7] << 8) if ($dLen > 7);
|
|
}
|
|
|
|
if ($command->{PARSEOPTS}{'dt1'}) { # time in data[1], data[2]=0 (DIM)
|
|
$command->{TIME1} = sprintf ('%.0f', $command->{DATA}[1]*16/25 + 0.1) if ($dLen > 2);
|
|
}
|
|
if ($command->{PARSEOPTS}{'dt2'}) { # time in data[1], data[2]=0 (DIM)
|
|
$command->{VALUE} = sprintf ('%.0f', $command->{DATA}[1]) if ($dLen > 2);
|
|
$command->{TIME1} = sprintf ('%.0f', $command->{DATA}[2]*16/25 + 0.1) if ($dLen > 2);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
# todo: zumindest bei emds können mehrere codes (channel/function) nacheinender in einer message kommen
|
|
# wenn zwei tasten gleichzeitig gedrückt werden...
|
|
|
|
##########################################################################################
|
|
# Called from ParseFrames when a valid command frame and its ACK have been received
|
|
# all data is in $hash->{COMMAND}
|
|
# call ParsePHCCode to split code into channel / function, find function name and options
|
|
# call ParseOptions and then set readings / create events
|
|
sub ParseCommands {
|
|
my $hash = shift; # reference to Fhem device hash
|
|
my $command = shift; # reference to command hash containing ADR and CMD
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
|
|
my $err = ParsePHCCode($hash, $command) // '';
|
|
ParseOptions($hash, $command) if (!$err);
|
|
my $lvl = ($err ? 3 : ($command->{MTYPE} eq "CLK" ? 5:4));
|
|
LogCommand($hash, $command, $err, $lvl);
|
|
|
|
# todo: new mode to set on/off depending on command instead of bits in ack message
|
|
# to avoid multiple events when a group of outputs on the same module is switched
|
|
# and every output creates a redundant event in every command
|
|
|
|
return if ($command->{MTYPE} eq "CLK"); # don't handle this noisy message
|
|
|
|
my $busEvents = AttrVal($name, "BusEvents", 'short'); # can be short, long or none
|
|
my $longChName = ChannelLongName($hash, $command, $command->{CHANNEL});
|
|
my $shortChName = ChannelShortName($hash, $command, $command->{CHANNEL});
|
|
my $cmd = $command->{FNAME};
|
|
my $event;
|
|
if ($busEvents eq 'long') {
|
|
$event = $longChName;
|
|
}
|
|
elsif ($busEvents eq 'short') {
|
|
$event = $shortChName;
|
|
} # if attr was set to none then $event stays undef
|
|
if ($event) {
|
|
$event .= ': ' . $cmd if ($cmd);
|
|
DoTrigger($name, $event);
|
|
Log3 $name, 5, "$name: ParseCommands create Event $event";
|
|
}
|
|
if (AttrVal($name, "EMDReadings", 0) && $command->{MTYPE} eq "EMD") {
|
|
readingsSingleUpdate($hash, $longChName, $cmd, 0); # descriptive reading of EMD command using the long name of the input channel but don't trigger event here
|
|
Log3 $name, 5, "$name: ParseCommands sets EMD reading $longChName to $cmd without event";
|
|
}
|
|
|
|
readingsBeginUpdate($hash);
|
|
readingsBulkUpdate($hash, 'LastCommand', CmdDetailText($hash, $command)); # reading with full Log-Details of command
|
|
|
|
# channel bits aus Feedback / Ack verarbeiten
|
|
if ($command->{PARSEOPTS}{'cbm'} || $command->{PARSEOPTS}{'cba'}) { # 8 channel bits in command message or in ACK
|
|
my $bin = unpack ("B8", pack ("C", ($command->{PARSEOPTS}{'cbm'} ? $command->{DATA}[1] : $command->{ACKDATA}[1])));
|
|
Log3 $name, 5, "$name: ParseCommands channel map = $bin";
|
|
my $channelBit = 7;
|
|
foreach my $c (split //, $bin) {
|
|
my $bitName = ChannelLongName($hash, $command, $channelBit);
|
|
Log3 $name, 5, "$name: ParseCommands sets reading $bitName for channel $channelBit to $c";
|
|
readingsBulkUpdate($hash, $bitName, $c) if ($bitName);
|
|
$channelBit --;
|
|
}
|
|
}
|
|
elsif ($command->{PARSEOPTS}{'cb2'}) { # 2 channel bits in ACKData (last two)
|
|
my $bin = substr (unpack ("B8", pack ("C", $command->{ACKDATA}[1])), -2);
|
|
Log3 $name, 5, "$name: ParseCommands channel map = $bin";
|
|
my $channelBit = 1;
|
|
foreach my $c (split //, $bin) {
|
|
my $bitName = ChannelLongName($hash, $command, $channelBit);
|
|
Log3 $name, 5, "$name: ParseCommands sets reading $bitName for channel $channelBit to $c";
|
|
readingsBulkUpdate($hash, $bitName, $c) if ($bitName);
|
|
$channelBit --;
|
|
}
|
|
}
|
|
|
|
my @data = @{$command->{DATA}};
|
|
if ($command->{PARSEOPTS}{'i'} && @data > 1) { # input with more data -> more commands
|
|
my $codeIdx = 1; # second code
|
|
while ($codeIdx < @data) {
|
|
Log3 $name, 5, "$name: ParseCommands now handles additional code at Index $codeIdx";
|
|
$command->{CODE} = $data[$codeIdx];
|
|
my $err = ParsePHCCode($hash, $command) // '';
|
|
my $lvl = ($err ? 3 : 4);
|
|
LogCommand($hash, $command, $err, $lvl);
|
|
DoTrigger($name, ChannelShortName($hash, $command, $command->{CHANNEL}) . ": " . $command->{FNAME});
|
|
$codeIdx++;
|
|
}
|
|
Log3 $name, 5, "$name: ParseCommands done";
|
|
}
|
|
|
|
readingsEndUpdate($hash, 1);
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# Called from the read functions
|
|
sub ParseFrames {
|
|
my $hash = shift;
|
|
my $name = $hash->{NAME};
|
|
|
|
#Log3 $name, 5, "$name: Parseframes called";
|
|
use bytes;
|
|
if (!$hash->{skipReason}) {
|
|
$hash->{skipBytes} = '';
|
|
$hash->{skipReason} = '';
|
|
};
|
|
|
|
BUFLOOP:
|
|
while ($hash->{helper}{buffer}) {
|
|
|
|
$hash->{RAWBUFFER} = unpack ('H*', $hash->{helper}{buffer});
|
|
Log3 $name, 5, "$name: Parseframes: loop with raw buffer: $hash->{RAWBUFFER}" if (!$hash->{skipReason});
|
|
|
|
my $rLen = length($hash->{helper}{buffer});
|
|
return if ($rLen < 4);
|
|
|
|
my ($adr, $lUTog, $rest) = unpack ('CCa*', $hash->{helper}{buffer});
|
|
my $xAdr = unpack('H2', $hash->{helper}{buffer});
|
|
my $tog = $lUTog >> 7; # toggle bit
|
|
my $len = $lUTog & 0x7F; # length
|
|
|
|
if ($len > 30) {
|
|
#Log3 $name, 5, "$name: Parseframes: len > 30, skip first byte of buffer $hash->{RAWBUFFER}";
|
|
$hash->{skipBytes} .= substr ($hash->{helper}{buffer}, 0, 1); # add, will be logged later
|
|
$hash->{skipReason} .= ($hash->{skipReason} ? ', ' : '') . 'Len > 30';
|
|
$hash->{helper}{buffer} = substr ($hash->{helper}{buffer}, 1);
|
|
next BUFLOOP;
|
|
}
|
|
|
|
if (($rLen < 20) && ($rLen < $len + 4)) {
|
|
Log3 $name, 5, "$name: Parseframes: len is $len so frame shoud be " . ($len + 4) . " but only $rLen read. wait for more";
|
|
return;
|
|
}
|
|
my $frame = substr($hash->{helper}{buffer}, 0, $len + 2); # the frame (adr, tog/len, cmd/data) without crc
|
|
my $hFrame = unpack ('H*', $frame);
|
|
|
|
# extract real pdu
|
|
my ($pld, $crc, $rest2) = unpack ("a[$len]va*", $rest); # v = little endian unsigned short, n would be big endian
|
|
my @data = unpack ('C*', $pld);
|
|
$crc = 0 if (!$crc);
|
|
|
|
# calculate CRC
|
|
my $crc1 = crc($frame, 16, 0xffff, 0xffff, 1, 0x1021, 1, 0);
|
|
my $fcrc = unpack ("H*", pack ("v", $crc)); # formatted crc as received
|
|
my $fcrc1 = unpack ("H*", pack ("v", $crc1)); # formatted crc as calculated
|
|
|
|
# check CRC
|
|
if ($crc != $crc1) {
|
|
my $skip = 1;
|
|
#Log3 $name, 5, "$name: Parseframes: CRC error for $hFrame $fcrc, calc $fcrc1) - skip $skip bytes of buffer $hash->{RAWBUFFER}";
|
|
$hash->{skipBytes} .= substr ($hash->{helper}{buffer}, 0, $skip);
|
|
$hash->{skipReason} .= ($hash->{skipReason} ? ', ' : '') . 'CRC Error';
|
|
$hash->{helper}{buffer} = substr ($hash->{helper}{buffer}, $skip);
|
|
next BUFLOOP;
|
|
}
|
|
Log3 $name, 4, "$name: Parseframes: skipped " .
|
|
unpack ("H*", $hash->{skipBytes}) . " reason: $hash->{skipReason}"
|
|
if $hash->{skipReason};
|
|
|
|
$hash->{skipBytes} = '';
|
|
$hash->{skipReason} = '';
|
|
$hash->{helper}{buffer} = $rest2;
|
|
#Log3 $name, 5, "$name: Parseframes: Adr $adr/x$xAdr Len $len T$tog Data " . unpack ('H*', $pld) . " (Frame $hFrame $fcrc) Rest " . unpack ('H*', $rest2)
|
|
Log3 $name, 5, "$name: Parseframes: Adr $adr/x$xAdr Len $len T$tog Data " . unpack ('H*', $pld) . " (Frame $hFrame $fcrc)"
|
|
if ($adr != 224); # todo: remove this filter later (hide noisy stuff)
|
|
|
|
$hash->{Toggle}{$adr} = ($tog ? 's' : 'c'); # save toggle for potential own sending of data
|
|
|
|
if ($hash->{COMMAND} && $hFrame eq $hash->{COMMAND}{FRAME}) {
|
|
Log3 $name, 4, "$name: Parseframes: Resend of $hFrame $fcrc detected";
|
|
next BUFLOOP;
|
|
}
|
|
|
|
my $cmd = $data[0];
|
|
|
|
if ($cmd == 1) { # Ping / Ping response
|
|
if ($hash->{COMMAND} && $hash->{COMMAND}{CODE} == 1
|
|
&& $hash->{COMMAND}{ADR} == $adr) { # ping response
|
|
# response to a previous ping
|
|
Log3 $name, 5, "$name: Parseframes: Ping response received";
|
|
$hash->{COMMAND}{ACKDATA} = \@data;
|
|
$hash->{COMMAND}{ACKLEN} = $len;
|
|
ParseCommands($hash, $hash->{COMMAND});
|
|
delete $hash->{COMMAND}; # done with this command
|
|
next BUFLOOP;
|
|
}
|
|
if (!$hash->{COMMAND}) { # new ping request
|
|
Log3 $name, 5, "$name: Parseframes: Ping request received";
|
|
}
|
|
else {
|
|
Log3 $name, 4, "$name: Parseframes: new Frame $hFrame $fcrc but no ACK for valid last Frame $hash->{COMMAND}{FRAME} - dropping last one";
|
|
delete $hash->{COMMAND}; # done with this command
|
|
}
|
|
my @oldData = @data; # save data in a new array that can be referenced by the command hash
|
|
$hash->{COMMAND} = {CODE => $data[0], ADR => $adr, LEN => $len, TOGGLE => $tog, DATA => \@oldData, FRAME => $hFrame};
|
|
next BUFLOOP;
|
|
}
|
|
elsif ($cmd == 254) { # reset
|
|
# todo: get module name / type and show real type / adr in Log, add to comand reading or go through ParseCommands with simulated acl len 0 ...
|
|
# parse payload in parsecommand
|
|
# por byte, many channel/ function bytes
|
|
Log3 $name, 4, "$name: Parseframes: configuration request for adr $adr received - frame is $hFrame $fcrc";
|
|
delete $hash->{COMMAND}; # done with this command
|
|
next BUFLOOP;
|
|
}
|
|
elsif ($cmd == 255) { # reset
|
|
Log3 $name, 4, "$name: Parseframes: reset for adr $adr received - frame is $hFrame $fcrc";
|
|
delete $hash->{COMMAND}; # done with this command
|
|
next BUFLOOP;
|
|
}
|
|
elsif ($cmd == 0) { # ACK received
|
|
Log3 $name, 5, "$name: Parseframes: Ack received";
|
|
if ($hash->{COMMAND}) {
|
|
if ($hash->{COMMAND}{ADR} != $adr) {
|
|
Log3 $name, 4, "$name: Parseframes: ACK frame $hFrame $fcrc does not match adr of last Frame $hash->{COMMAND}{FRAME}";
|
|
}
|
|
elsif ($hash->{COMMAND}{TOGGLE} != $tog) {
|
|
Log3 $name, 4, "$name: Parseframes: ACK frame $hFrame $fcrc does not match toggle of last Frame $hash->{COMMAND}{FRAME}";
|
|
}
|
|
else { # this ack is fine
|
|
$hash->{COMMAND}{ACKDATA} = \@data;
|
|
$hash->{COMMAND}{ACKLEN} = $len;
|
|
ParseCommands($hash, $hash->{COMMAND});
|
|
}
|
|
delete $hash->{COMMAND}; # done with this command
|
|
}
|
|
else {
|
|
Log3 $name, 4, "$name: Parseframes: ACK frame $hFrame $fcrc without a preceeding request - dropping";
|
|
}
|
|
next BUFLOOP;
|
|
}
|
|
else { # normal command - no ack, ping etc.
|
|
if ($hash->{COMMAND}) {
|
|
Log3 $name, 4, "$name: Parseframes: new Frame $hFrame $fcrc but no ACK for valid last Frame $hash->{COMMAND}{FRAME} - dropping last one";
|
|
}
|
|
Log3 $name, 5, "$name: Parseframes: $hFrame $fcrc is not an Ack frame, wait for ack to follow";
|
|
my @oldData = @data; # save data in a new array that can be referenced by the command hash
|
|
$hash->{COMMAND} = {CODE => $data[0], ADR => $adr, LEN => $len, TOGGLE => $tog, DATA => \@oldData, FRAME => $hFrame};
|
|
# todo: set timeout timer if not ACK received
|
|
}
|
|
} # BUFLOOP
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
# Called from the global loop, when the select for hash->{FD} reports data
|
|
sub ReadFn {
|
|
my $hash = shift;
|
|
my $name = $hash->{NAME};
|
|
my $now = gettimeofday();
|
|
|
|
# throw away old stuff
|
|
if ($hash->{helper}{lastRead} && ($now - $hash->{helper}{lastRead}) > 1) {
|
|
if ($hash->{helper}{buffer}) {
|
|
Log3 $name, 5, "throw away " . unpack ('H*', $hash->{helper}{buffer});
|
|
}
|
|
$hash->{helper}{buffer} = "";
|
|
}
|
|
$hash->{helper}{lastRead} = $now;
|
|
|
|
my $buf = DevIo_SimpleRead($hash);
|
|
return if(!defined($buf));
|
|
|
|
$hash->{helper}{buffer} .= $buf;
|
|
|
|
ParseFrames($hash);
|
|
return;
|
|
}
|
|
|
|
|
|
#####################################
|
|
sub ReadyFn {
|
|
my $hash = shift;
|
|
if ($hash->{STATE} eq "disconnected") {
|
|
$hash->{devioLoglevel} = (AttrVal($hash->{NAME}, "silentReconnect", 0) ? 4 : 3);
|
|
return DevIo_OpenDev($hash, 1, undef);
|
|
}
|
|
# This is relevant for windows/USB only
|
|
my $po = $hash->{USBDev};
|
|
my ($BlockingFlags, $InBytes, $OutBytes, $ErrorFlags) = $po->status;
|
|
return ($InBytes>0);
|
|
}
|
|
|
|
|
|
###############################################################
|
|
# split code into channel and function depending on module type
|
|
sub SplitPHCCode {
|
|
my $hash = shift; # phc device hash ref
|
|
my $mType = shift; # module type (AMD, EMD, ...)
|
|
my $code = shift; # code byte in protocol to be split into channel and function
|
|
|
|
#Log3 $hash->{NAME}, 5, "$hash->{NAME}: SplitPHCCode called with code $code and type $mType";
|
|
my @splitArr = @{$CodeSplit{$mType}};
|
|
#Log3 $hash->{NAME}, 5, "$hash->{NAME}: SplitCode splits code " .
|
|
# sprintf ('%02d', $code) . " for type $mType into " .
|
|
# " channel " . ($code >> $splitArr[0]) . " / function " . ($code & $splitArr[1]);
|
|
return ($code >> $splitArr[0], $code & $splitArr[1]); # channel, function
|
|
}
|
|
|
|
|
|
###############################################################
|
|
# log message with command parse data
|
|
sub LogCommand {
|
|
my ($hash, $command, $msg, $level) = @_;
|
|
Log3 $hash->{NAME}, $level, "$hash->{NAME}: " . FhemCaller() . ' ' . CmdDetailText($hash, $command) . " $msg";
|
|
return;
|
|
}
|
|
|
|
|
|
###############################################################
|
|
# get Text like EMD12i01
|
|
sub ChannelShortName {
|
|
my $hash = shift; # device hash
|
|
my $command = shift; # reference to command hash with ADR, MTYPE, CTYPE
|
|
my $channel = shift; # channel number
|
|
|
|
my $fmAdr = sprintf('%02d', ($command->{ADR} & 0x1F)); # relative module address formatted with two digits
|
|
my $mType = $command->{MTYPE};
|
|
|
|
my $cText = ($mType ? $mType . $fmAdr : 'Module' . sprintf ("x%02X", $command->{ADR})) .
|
|
($command->{CTYPE} ? $command->{CTYPE} : "?") .
|
|
(defined($channel) ? sprintf('%02d', $channel) : "");
|
|
#Log3 $hash->{NAME}, 5, "$hash->{NAME}: ChannelText is $cText";
|
|
return $cText;
|
|
}
|
|
|
|
|
|
###############################################################
|
|
# channel description if attr is defined
|
|
# or internal mod/chan text like EMD12i01
|
|
sub ChannelLongName {
|
|
my $hash = shift; # device hash
|
|
my $command = shift; # reference to command hash with ADR, MTYPE, CTYPE
|
|
my $channel = shift; # channel number
|
|
my $name = $hash->{NAME}; # Fhem device name
|
|
my $cName = ChannelShortName($hash, $command, $channel);
|
|
my $descr = AttrVal($name, "channel${cName}description", '');
|
|
my $bitName = SanitizeReadingName( $descr ? $descr : $cName);
|
|
#Log3 $hash->{NAME}, 5, "$hash->{NAME}: ChannelDesc is looking for $aName or $cName, Result name is $bitName";
|
|
return $bitName;
|
|
}
|
|
|
|
|
|
###############################################################
|
|
# full detail of a command for logging
|
|
sub CmdDetailText {
|
|
my $hash = shift; # device hash
|
|
my $command = shift; # reference to command hash with ADR, MTYPE, CTYPE
|
|
my $channel = $command->{CHANNEL}; # channel on PHC module
|
|
my $cDesc = ChannelLongName($hash, $command, $channel);
|
|
my $start = ChannelShortName($hash, $command, $channel);
|
|
return ($start ? $start : "") .
|
|
(defined($command->{CHANNEL}) ? " Ch$command->{CHANNEL}" : "") .
|
|
(defined($command->{FUNCTION}) ? " F$command->{FUNCTION}" : "") .
|
|
($command->{FNAME} ? " $command->{FNAME}" : "") .
|
|
(defined($command->{PRIO}) ? " P$command->{PRIO}" : "") .
|
|
(defined($command->{PRIO}) ? ($command->{PSET} ? " (Set)" : " (no Set)") : "") .
|
|
(defined($command->{VALUE}) ? " Value $command->{VALUE}" : "") .
|
|
(defined($command->{TIME1}) ? " Time1 $command->{TIME1}" : "") .
|
|
(defined($command->{TIME2}) ? " Time2 $command->{TIME2}" : "") .
|
|
(defined($command->{TIME3}) ? " Time3 $command->{TIME3}" : "") .
|
|
" data " . join (",", map ({sprintf ("x%02X", $_)} @{$command->{DATA}})) .
|
|
" ack " . join (",", map ({sprintf ("x%02X", $_)} @{$command->{ACKDATA}})) .
|
|
" tg " . $command->{TOGGLE} .
|
|
($cDesc ? " $cDesc" : "");
|
|
}
|
|
|
|
|
|
###############################################################
|
|
# convert description into a usable reading name
|
|
sub SanitizeReadingName {
|
|
my $bitName = shift;
|
|
$bitName =~ s/ä/ae/g;
|
|
$bitName =~ s/ö/oe/g;
|
|
$bitName =~ s/ü/ue/g;
|
|
$bitName =~ s/Ä/Ae/g;
|
|
$bitName =~ s/Ö/Oe/g;
|
|
$bitName =~ s/Ü/Ue/g;
|
|
$bitName =~ s/ß/ss/g;
|
|
$bitName =~ s/ / /g;
|
|
$bitName =~ s/ -/-/g;
|
|
$bitName =~ s/- /-/g;
|
|
$bitName =~ s/ /_/g;
|
|
$bitName =~ s/[^A-Za-z0-9\-]/_/g;
|
|
$bitName =~ s/__/_/g;
|
|
$bitName =~ s/__/_/g;
|
|
return $bitName;
|
|
}
|
|
|
|
|
|
1;
|
|
|
|
=pod
|
|
=item device
|
|
=item summary retrieves events / readings from PHC bus and simulates input modules
|
|
=item summary_DE hört den PHC-Bus ab, erzeugt Events / Readings und simuliert EMDs
|
|
=begin html
|
|
|
|
<a id="PHC"></a>
|
|
<h3>PHC</h3>
|
|
<ul>
|
|
PHC provides a way to communicate with the PHC bus from Peha. It listens to the communication on the PHC bus, tracks the state of output modules in readings and can send events to the bus / "Steuermodul" by simulating PHC input modules.<br>
|
|
It can import the channel list file that is exportable from the Peha "Systemsoftware" to get names of existing modules and channels.<br>
|
|
This module can not replace a Peha "Steuermodul". It is also not possible to directly send commands to output modules on the PHC bus. If you want to
|
|
interact with output modules then you have to define the action on the Peha "Steuermodul" and send the input event to it through a virtual input module. <br>
|
|
If you define a virtual input module then it needs to be given a unique address in the allowed range for input modules and this address must not be used by existing input modules.
|
|
<br><br>
|
|
|
|
<b>Prerequisites</b>
|
|
<ul>
|
|
<br>
|
|
<li>
|
|
This module requires the Perl modules Device::SerialPort or Win32::SerialPort and Digest::CRC.<br>
|
|
To connect to the PHC bus it requires an RS485 adapter that connects directly to the PHC bus with GND, +data and -data.
|
|
</li>
|
|
</ul>
|
|
<br>
|
|
|
|
<a id="PHC-define"></a>
|
|
<b>Define</b>
|
|
<ul>
|
|
<code>define <name> PHC <Device></code><br>
|
|
The module connects to the PHC bus with the specified device (RS485 adapter)<br>
|
|
<br>
|
|
Examples:<br>
|
|
<br>
|
|
<ul><code>define MyPHC PHC /dev/ttyRS485</code></ul><br>
|
|
</ul>
|
|
<br>
|
|
|
|
<a id="PHC-configuration"></a>
|
|
<b>Configuration of the module</b><br><br>
|
|
<ul>
|
|
The module doesn't need configuration to listen to the bus and create readings. <br>
|
|
Only if you want to send input to the bus, you need to define a virtual input module with an address that is not used by real modules.<br>
|
|
Virtual input modules and their channels are defined using attributes.<br>
|
|
|
|
Example:<br>
|
|
<pre>
|
|
attr MyPHC virtEMD25C2Name VirtLightSwitch
|
|
</pre>
|
|
|
|
Defines a virtual light switch as channel 2 on the virtual input nodule with address 25. This light switch can then be used with set comands like
|
|
<pre>
|
|
set MyPHC VirtualLightSwitch ein>0
|
|
</pre>
|
|
The set options offered here are the event types that PHC knows for input modules. They are ein>0, ein>1, ein>2, aus, aus<1.
|
|
To react on such events in the PHC system you need to add a reaction to the programming of your PHC control module.
|
|
</ul>
|
|
<br>
|
|
|
|
<a id="PHC-set"></a>
|
|
<b>Set-Commands</b><br>
|
|
|
|
<ul>
|
|
<li><b>importChannelList</b></li>
|
|
reads an xml file that is exportable by the Peha "Systemsoftware" that contains addresses and names of existing modules and channels on the PHC bus.<br>
|
|
The path to the filename to import is relative to the Fhem base directory.<br>
|
|
Example:<br>
|
|
<pre>
|
|
set MyPHC importChannelList Kanalliste.xml
|
|
</pre>
|
|
If Kanalliste.xml is located in /opt/fhem.<br>
|
|
<br><br>
|
|
more set options are created based on the attributes defining virtual input modules / channels<br>
|
|
Every input channel for which an attribute like <code>virtEMDxyCcName</code> is defined will create a valid set option with name specified in the attribute.<br>
|
|
</ul>
|
|
<br>
|
|
<a id="PHC-get"></a>
|
|
<b>Get-Commands</b><br>
|
|
<ul>
|
|
none so far
|
|
</ul>
|
|
<br>
|
|
<a id="PHC-attr"></a>
|
|
<b>Attributes</b><br><br>
|
|
<ul>
|
|
<li><a href="#do_not_notify">do_not_notify</a></li>
|
|
<li><a href="#readingFnAttributes">readingFnAttributes</a></li>
|
|
|
|
<li><a id="PHC-attr-BusEvents">BusEvents</a><br>
|
|
this attribute controls what kind of events are generated when messages are received from the PHC bus regardless of any readings that might be created.
|
|
If set to simple (which is the default) then short events like EMD12i01: Ein > 0 will be generated.
|
|
If set to long then instead of EMD12i01 the module will use a name specified with a channel description attribue (see above).
|
|
If set to none then no events will be created except the ones that result from readings that are created when output modules send their channel state.
|
|
</li>
|
|
<li><a id="PHC-attr-HTTPMOD">HTTPMOD</a><br>
|
|
Name of an HTTPMOD-device which is defined as http://your-stm-ip:6680/ 0
|
|
</li>
|
|
<li><a id="STM_ADR">STM_ADR</a><br>
|
|
Address of the control module (typically 0) to be used in the XMLRPC communication to directly set an output (STM Version 3 with ethernet connection only)
|
|
</li>
|
|
<li><a id="PHC-attr-EMDReadings">EMDReadings</a><br>
|
|
if this attribute is set to 1 then the module will create readings for each input channel.
|
|
These readings will contain the last command received from an input, e.g. ein>0<br>
|
|
These readings will not create events because by default any input message on the bus will create an event anyway (see BusEvents).
|
|
</li>
|
|
<li><a id="PHC-attr-sendEcho">sendEcho</a><br>
|
|
controls if bus commands sent should be fed back to the read function.
|
|
</li>
|
|
<li><a id="PHC-attr-virtEMD[0-9]+C[0-9]+Name" data-pattern="virtEMD.*">virtEMD[0-9]+C[0-9]+Name</a>
|
|
Defines a virtual input module with a given address and a name for a channel of that input module.<br>
|
|
For example:<br>
|
|
<pre>
|
|
attr MyPHC virtEMD25C1Name LivingRoomLightSwitch
|
|
attr MyPHC virtEMD25C2Name KitchenLightSwitch
|
|
</pre>
|
|
</li>
|
|
<li><a id="PHC-attr-module[0-9]+description" data-pattern="module.*description">module[0-9]+description</a><br>
|
|
this attribute is typically created when you import a channel list with <code>set MyPHCDevice importChannelList</code>.<br>
|
|
It gives a name to a module. This name is used for better readability when logging at verbose level 4 or 5.
|
|
</li>
|
|
<li><a id="PHC-attr-module[0-9]+type" data-pattern="module.*type">module[0-9]+type</a><br>
|
|
this attribute is typically created when you import a channel list with <code>set MyPHCDevice importChannelList</code>.<br>
|
|
It defines the type of a module. This information is needed since some module types (e.g. EMD and JRM) use the same address space but a different
|
|
protocol interpretation so parsing is only correct if the module type is known.
|
|
</li>
|
|
<li><a id="PHC-attr-channel(EMD|AMD|JRM|DIM|UIM|MCC|MFN)[0-9]+[io]?[0-9]+description"
|
|
data-pattern="channel.*description">channel(EMD|AMD|JRM|DIM|UIM|MCC|MFN)[0-9]+[io]?[0-9]+description</a><br>
|
|
this attribute is typically created when you import a channel list with <code>set MyPHCDevice importChannelList</code>.<br>
|
|
It defines names for channels of modules.
|
|
These names are used for better readability when logging at verbose level 4 or 5.
|
|
They also define the names of readings that are automatically created when the module listens to the PHC bus.
|
|
</li>
|
|
<li><a id="PHC-attr-channel(EMD|AMD|JRM|DIM|UIM|MCC|MFN)[0-9]+[io]?[0-9]+set"
|
|
data-pattern="channel.*set">channel(EMD|AMD|JRM|DIM|UIM|MCC|MFN)[0-9]+[io]?[0-9]+set</a><br>
|
|
Only for STM version 3! This allows sending commands to output modules (so far tested with AMD, JRM or DIM) through the XML-RPC interface of a version 3 STM.
|
|
To work this feature needs an HTTPMOD device which is defined as http://your-stm-ip:6680/ 0<br>
|
|
The name of this HTTPMOD device then needs to be linked here via an attr named HTTPMOD.
|
|
</li>
|
|
<li><a id="PHC-attr-silentReconnect">silentReconnect</a><br>
|
|
this attribute controls at what loglevel reconnect messages from devIO will be logged. Without this attribute they will be logged at level 3.
|
|
If this attribute is set to 1 then such messages will be logged at level 4.
|
|
</li>
|
|
<br>
|
|
</ul>
|
|
<br>
|
|
</ul>
|
|
|
|
=end html
|
|
=cut
|
|
|
|
|