FHEM/fhem-mirror
2
0
Fork 0
mirror of https://github.com/fhem/fhem-mirror.git synced 2025-03-12 16:46:35 +00:00
Code Issues Releases Wiki Activity

HMCCU: Update for 4.4 Beta

Browse Source 
git-svn-id: https://svn.fhem.de/fhem/trunk@21242 2b470e98-0d58-463d-a4d8-8e2adae1ed80
This commit is contained in:
zap 2020-02-21 17:02:04 +00:00
parent 24a463ae8c
commit 2b8aa902d7
3 changed files with 206 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
fhem/contrib/HMCCU/FHEM/88_HMCCU.pm
View File

@ -4,7 +4,7 @@
#
# $Id: 88_HMCCU.pm 18745 2019-02-26 17:33:23Z zap $
#
# Version 4.4.008
# Version 4.4.010
#
# Module for communication between FHEM and Homematic CCU2/3.
#
@ -43,6 +43,8 @@ use SubProcess;
use HMCCUConf;
# Import configuration data
my $HMCCU_ROLES = \%HMCCUConf::HMCCU_ROLES;
my $HMCCU_ATTR = \%HMCCUConf::HMCCU_ATTR;
my $HMCCU_CHN_DEFAULTS = \%HMCCUConf::HMCCU_CHN_DEFAULTS;
my $HMCCU_DEV_DEFAULTS = \%HMCCUConf::HMCCU_DEV_DEFAULTS;
my $HMCCU_SCRIPTS = \%HMCCUConf::HMCCU_SCRIPTS;
@ -52,7 +54,7 @@ my %HMCCU_CUST_CHN_DEFAULTS;
my %HMCCU_CUST_DEV_DEFAULTS;
# HMCCU version
my $HMCCU_VERSION = '4.4.008';
my $HMCCU_VERSION = '4.4.010';
# Constants and default values
my $HMCCU_MAX_IOERRORS = 100;
@ -337,12 +339,14 @@ sub HMCCU_GetDatapoint ($@);
sub HMCCU_GetDatapointAttr ($$$$$);
sub HMCCU_GetDatapointCount ($$$);
sub HMCCU_GetDatapointList ($$$);
sub HMCCU_GetSpecialCommands ($$);
sub HMCCU_GetSpecialDatapoints ($$$$$);
sub HMCCU_GetStateValues ($$;$);
sub HMCCU_GetStateValues ($$$;$);
sub HMCCU_GetSwitchDatapoint ($$$);
sub HMCCU_GetValidDatapoints ($$$$$);
sub HMCCU_IsValidDatapoint ($$$$$);
# sub HMCCU_SetDatapoint ($$$);
sub HMCCU_SetDefaultAttributes ($;$);
sub HMCCU_SetMultipleDatapoints ($$);
sub HMCCU_SetMultipleParameters ($$$);
@ -2669,6 +2673,7 @@ sub HMCCU_FormatReadingValue ($$$)
HMCCU_Trace ($hash, 2, $fnc, "Value undefined for datapoint $dpt");
return $value;
}
my $stripnumber = HMCCU_GetAttrStripNumber ($hash);
if ($stripnumber ne 'null' && $value =~ /^[+-]?\d*\.?\d+(?:(?:e|E)\d+)?$/) {
@ -3174,7 +3179,7 @@ sub HMCCU_SubstVariables ($$$)
if (defined ($clhash->{hmccu}{dp}{$dp}{VALUES}{VAL})) {
$text =~ s/\%\{?$dp\}?/$clhash->{hmccu}{dp}{$dp}{VALUES}{VAL}/g;
$text =~ s/\%\{?$dpt\}?/$clhash->{hmccu}{dp}{$dp}{VALUES}{VAL}/g;
$text =~ s/$dp/$clhash->{hmccu}{dp}{$dp}{VAL}/g;
$text =~ s/$dp/$clhash->{hmccu}{dp}{$dp}{VALUES}{VAL}/g;
}
}
@ -3667,7 +3672,7 @@ sub HMCCU_UpdateDeviceRoles ($$;$$)
my $devDesc = HMCCU_GetDeviceDesc ($ioHash, $address, $iface);
if (defined($devDesc)) {
if ($clType eq 'HMCCUCHN' && defined($devDesc->{TYPE})) {
$clHash->{ccurole} = $devDesc->{TYPE};
$clHash->{hmccu}{role} = $devDesc->{TYPE};
}
elsif ($clType eq 'HMCCUDEV' && defined($devDesc->{CHILDREN})) {
my @roles = ();
@ -3677,7 +3682,7 @@ sub HMCCU_UpdateDeviceRoles ($$;$$)
push @roles, $childDevDesc->{INDEX}.':'.$childDevDesc->{TYPE};
}
}
$clHash->{ccurole} = join(',', @roles) if (scalar(@roles) > 0);
$clHash->{hmccu}{role} = join(',', @roles) if (scalar(@roles) > 0);
}
}
}
@ -3722,15 +3727,17 @@ sub HMCCU_GetChannelRole ($;$)
{
my ($clHash, $chnNo) = @_;
return '' if (!defined($clHash->{ccurole}));
return '' if (!defined($clHash->{hmccu}{role}));
if ($clHash->{TYPE} eq 'HMCCUCHN') {
return $clHash->{ccurole};
return $clHash->{hmccu}{role};
}
elsif ($clHash->{TYPE} eq 'HMCCUDEV' && defined($chnNo)) {
foreach my $role (split(',', $clHash->{ccurole})) {
my ($c, $r) = split(':', $role);
return $r if (defined($r) && "$c" eq "$chnNo");
elsif ($clHash->{TYPE} eq 'HMCCUDEV') {
if (defined($chnNo)) {
foreach my $role (split(',', $clHash->{hmccu}{role})) {
my ($c, $r) = split(':', $role);
return $r if (defined($r) && "$c" eq "$chnNo");
}
}
}
@ -3844,6 +3851,11 @@ sub HMCCU_GetDeviceDesc ($$;$)
return undef if (!exists($hash->{hmccu}{device}));
if (!defined($address)) {
HMCCU_Log ($hash, 2, "Address not defined for device\n".stacktraceAsString(undef));
return undef;
}
my @ifaceList = ();
if (defined($iface)) {
push (@ifaceList, $iface);
@ -4179,8 +4191,10 @@ sub HMCCU_GetParamDef ($$$$)
{
my ($hash, $object, $paramset, $parameter) = @_;
return undef if (!defined($object));
my $devDesc = ref($object) eq 'HASH' ? $object : HMCCU_GetDeviceDesc ($hash, $object);
if (defined($devDesc)) {
# Build device address and channel number
my $a = $devDesc->{ADDRESS};
@ -4248,6 +4262,8 @@ sub HMCCU_GetParamValue ($$$$$)
'BOOL' => { 0 => 'false', 1 => 'true' }
);
return $value if (!defined($object));
$paramset = 'LINK' if ($paramset =~ /^LINK\..+$/);
my $paramDef = HMCCU_GetParamDef ($hash, $object, $paramset, $parameter);
if (defined($paramDef)) {
@ -4454,11 +4470,13 @@ sub HMCCU_UpdateParamsetReadings ($$$;$)
# Loop over all addresses
foreach my $a (@addList) {
next if (!exists($objects->{$a}));
# Loop over all channels of device, including channel 'd'
foreach my $c (keys %{$objects->{$a}}) {
next if (($clType eq 'HMCCUCHN' && "$c" ne "$chnNo" && "$c" ne "0" && "$c" ne "d"));
my $chnAddr = "$devAddr:$c";
my $chnAddr = "$a:$c";
my $devDesc = HMCCU_GetDeviceDesc ($ioHash, $chnAddr, $clHash->{ccuif});
my $chnType = defined($devDesc) ? $devDesc->{TYPE} : HMCCU_GetChannelRole ($clHash, $c);
@ -4483,7 +4501,8 @@ sub HMCCU_UpdateParamsetReadings ($$$;$)
$sv = HMCCU_ScaleValue ($clHash, $c, $p, $v, 0);
$fv = HMCCU_FormatReadingValue ($clHash, $sv, $p);
$cv = HMCCU_Substitute ($fv, $clHash, 0, $c, $p, $chnType, $devDesc);
$cv = HMCCU_GetParamValue ($ioHash, $devDesc, $ps, $p, $fv) if ("$fv" eq "$cv");
$cv = HMCCU_GetParamValue ($ioHash, $devDesc, $ps, $p, $fv)
if (defined($devDesc) && "$fv" eq "$cv");
HMCCU_UpdateInternalValues ($clHash, $chKey, $ps, 'SVAL', $cv);
push @chKeys, $chKey;
@ -4757,17 +4776,16 @@ sub HMCCU_UpdateMultipleDevices ($$)
my @devlist = HMCCU_FindClientDevices ($hash, "(HMCCUDEV|HMCCUCHN)", undef,
"ccudevstate=active");
foreach my $d (@devlist) {
my $ch = $defs{$d};
if (!defined ($ch)) {
my $clHash = $defs{$d};
if (!defined ($clHash)) {
HMCCU_Log ($name, 2, "Can't find hash for device $d");
next;
}
my @addrlist = HMCCU_GetAffectedAddresses ($ch);
my @addrlist = HMCCU_GetAffectedAddresses ($clHash);
next if (scalar (@addrlist) == 0);
foreach my $addr (@addrlist) {
if (exists ($objects->{$addr})) {
# my $rc = HMCCU_UpdateSingleDevice ($hash, $ch, $objects, \@addrlist);
my $rc = HMCCU_UpdateParamsetReadings ($hash, $ch, $objects, \@addrlist);
my $rc = HMCCU_UpdateParamsetReadings ($hash, $clHash, $objects, \@addrlist);
$c++ if (ref($rc));
last;
}
@ -6873,35 +6891,69 @@ sub HMCCU_GetDatapointCount ($$$)
}
}
######################################################################
# Set default attributes for client device.
######################################################################
sub HMCCU_SetDefaultAttributes ($;$)
{
my ($clHash, $ctrlChn) = @_;
my $clName = $clHash->{NAME};
my $role = HMCCU_GetChannelRole ($clHash, $ctrlChn);
if ($role ne '' && exists($HMCCU_ATTR->{$role})) {
foreach my $a (keys %{$HMCCU_ATTR->{$role}}) {
CommandAttr (undef, "$clName $a ".$HMCCU_ATTR->{$role}{$a});
}
return 1;
}
else {
return 0;
}
}
######################################################################
# Get state values of client device
# Return '' if no state values available
######################################################################
sub HMCCU_GetStateValues ($$;$)
sub HMCCU_GetStateValues ($$$;$)
{
my ($clHash, $dpt, $oper) = @_;
$oper = 2 if (!defined($oper));
my %stateValues = (
"STATE:BOOL" => "on:true,off:false",
"LEVEL:FLOAT" => "on:100,off:0",
"PRESS_SHORT:ACTION" => "on:true,press:true"
);
my ($clHash, $roleCmds, $dpt, $oper) = @_;
return '' if (!defined($roleCmds));
my $ioHash = HMCCU_GetHash ($clHash);
return '' if (!defined($ioHash));
$oper = 2 if (!defined($oper));
my $sv = AttrVal ($clHash->{NAME}, 'statevals', '');
if ($sv eq '') {
my $paramDef = HMCCU_GetParamDef ($ioHash, $clHash->{ccuaddr}, 'VALUES', $dpt);
return $stateValues{"$dpt:$paramDef->{TYPE}"} if (defined($paramDef) &&
$paramDef->{OPERATIONS} & $oper && exists($stateValues{"$dpt:$paramDef->{TYPE}"}));
return $roleCmds->{$dpt} if (defined($paramDef) &&
$paramDef->{OPERATIONS} & $oper && exists($roleCmds->{$dpt}));
}
else {
$sv =~ s/,/ /g;
}
return $sv;
}
######################################################################
# Return additional commands depending on the channel role.
######################################################################
sub HMCCU_GetSpecialCommands ($$)
{
my ($clHash, $ctrlChn) = @_;
my $role = HMCCU_GetChannelRole ($clHash, $ctrlChn);
return $HMCCU_ROLES->{$role} if ($role ne '' && exists($HMCCU_ROLES->{$role}));
return undef;
}
######################################################################
# Get channels and datapoints from attributes statechannel,
# statedatapoint and controldatapoint.
@ -6969,8 +7021,8 @@ sub HMCCU_GetSpecialDatapoints ($$$$$)
}
}
if (exists($hash->{ccurole})) {
my $ccuRole = $hash->{ccurole};
if (exists($hash->{hmccu}{role})) {
my $ccuRole = $hash->{hmccu}{role};
if ($type eq 'HMCCUCHN') {
my ($da, $dc) = HMCCU_SplitChnAddr ($hash->{ccuaddr});
$sc = $dc;
@ -7069,17 +7121,33 @@ sub HMCCU_GetAttrStripNumber ($)
{
my ($hash) = @_;
my $fnc = "GetAttrStripNumber";
my $type = $hash->{TYPE};
my %strip = (
'BLIND' => '0', 'DIMMER' => '0'
);
my $snDef = '1';
if ($hash->{TYPE} ne 'HMCCU') {
my $ioHash = HMCCU_GetHash ($hash);
if (defined ($ioHash)) {
$snDef = AttrVal ($ioHash->{NAME}, 'ccudef-stripnumber', $snDef);
}
my $ioHash = HMCCU_GetHash ($hash);
if (defined ($ioHash)) {
$snDef = AttrVal ($ioHash->{NAME}, 'ccudef-stripnumber', $snDef);
}
else {
$snDef = AttrVal ($hash->{NAME}, 'ccudef-stripnumber', $snDef);
if (exists($hash->{hmccu}{role})) {
if ($type eq 'HMCCUDEV') {
foreach my $cr (split(',', $hash->{hmccu}{role})) {
my ($c, $r) = split(':', $cr);
if (exists($strip{$r})) {
$snDef = $strip{$r};
last;
}
}
}
elsif ($type eq 'HMCCUCHN') {
$snDef = $strip{$hash->{hmccu}{role}} if (exists($strip{$hash->{hmccu}{role}}));
}
}
my $stripnumber = AttrVal ($hash->{NAME}, 'stripnumber', $snDef);
@ -7500,7 +7568,7 @@ sub HMCCU_HMCommand ($$$)
}
else {
HMCCU_Log ($io_hash, 2, "Error during HTTP request: $err");
HMCCU_Trace ($cl_hash, 2, $fnc, "Response=$response");
HMCCU_Trace ($cl_hash, 2, $fnc, "Response=".(defined($response) ? $response : 'undef'));
return undef;
}
@ -7576,6 +7644,10 @@ sub HMCCU_HMScriptExt ($$$$$)
my $code = $hmscript;
my $scrname = '';
if ($hash->{TYPE} ne 'HMCCU') {
HMCCU_Log ($hash, 2, stacktraceAsString(undef));
}
return HMCCU_LogError ($hash, 2, "CCU host name not defined") if (!exists ($hash->{host}));
my $host = $hash->{host};

144
fhem/contrib/HMCCU/FHEM/88_HMCCUCHN.pm
View File

@ -4,7 +4,7 @@
#
# $Id: 88_HMCCUCHN.pm 18552 2019-02-10 11:52:28Z zap $
#
# Version 4.4.008
# Version 4.4.010
#
# (c) 2020 zap (zap01 <at> t-online <dot> de)
#
@ -242,7 +242,7 @@ sub HMCCUCHN_Set ($@)
$opt = lc($opt);
my $rocmds = "clear defaults:noArg";
my $rwcmds = "clear config control datapoint defaults:noArg link values";
my $rwcmds = "clear config control datapoint defaults:noArg values";
# Get I/O device, check device state
return undef if (!defined ($hash->{ccudevstate}) || $hash->{ccudevstate} eq 'pending' ||
@ -264,9 +264,33 @@ sub HMCCUCHN_Set ($@)
my $ccuaddr = $hash->{ccuaddr};
my $ccuif = $hash->{ccuif};
my $ccuflags = AttrVal ($name, 'ccuflags', 'null');
# Get state and control datapoints
my ($sc, $sd, $cc, $cd) = HMCCU_GetSpecialDatapoints ($hash, '', '', '', '');
my $stateVals = HMCCU_GetStateValues ($hash, $cd, 2);
my %stateCmds = split (/[:,]/, $stateVals);
# Get additional commands (including state commands)
my $roleCmds = HMCCU_GetSpecialCommands ($hash, $cc);
my $cmdList = '';
my %addCmds;
foreach my $d (keys %$roleCmds) {
my @cmds = split(' ', $roleCmds->{$d});
foreach my $cmdDef (@cmds) {
my ($cmd, $argDef) = split(':', $cmdDef);
$addCmds{$cmd} = "$d=$argDef";
$cmdList .= " $cmd";
if ($argDef !~ /^\?/) {
my @argList = split(',', $argDef);
$cmdList .= scalar(@argList) > 1 ? ':'.$argDef : ':noArg';
}
}
}
# Get state values related to control command and datapoint
my $stateVals = HMCCU_GetStateValues ($hash, $roleCmds, $cd, 2);
my @stateCmdList = split (/[:\s]/, $stateVals);
HMCCU_Log ($hash, 2, "Odd number for values in $stateVals") if ((scalar(@stateCmdList) % 2) > 0);
my %stateCmds = @stateCmdList;
my @states = keys %stateCmds;
my $result = '';
@ -328,16 +352,16 @@ sub HMCCUCHN_Set ($@)
);
return HMCCU_SetError ($hash, min(0, $rc));
}
elsif (exists($stateCmds{$opt})) {
return HMCCU_SetError ($hash, -14) if ($cd eq '');
return HMCCU_SetError ($hash, -8)
if (!HMCCU_IsValidDatapoint ($hash, $ccutype, $ccuaddr, $cd, 2));
$rc = HMCCU_SetMultipleDatapoints ($hash,
{ "001.$ccuif.$ccuaddr.$cd" => $stateCmds{$opt} }
);
return HMCCU_SetError ($hash, min(0, $rc));
}
# elsif (exists($stateCmds{$opt})) {
# return HMCCU_SetError ($hash, -14) if ($cd eq '');
# return HMCCU_SetError ($hash, -8)
# if (!HMCCU_IsValidDatapoint ($hash, $ccutype, $ccuaddr, $cd, 2));
#
# $rc = HMCCU_SetMultipleDatapoints ($hash,
# { "001.$ccuif.$ccuaddr.$cd" => $stateCmds{$opt} }
# );
# return HMCCU_SetError ($hash, min(0, $rc));
# }
elsif ($opt eq 'toggle') {
return HMCCU_SetError ($hash, -15) if ($stateVals eq '');
return HMCCU_SetError ($hash, -12) if ($cc eq '');
@ -369,6 +393,28 @@ sub HMCCUCHN_Set ($@)
);
return HMCCU_SetError ($hash, min(0, $rc));
}
elsif (exists($addCmds{$opt})) {
my $value;
my ($dpt, $par) = split('=', $addCmds{$opt});
$par = '' if (!defined($par));
return HMCCU_SetError ($hash, -8)
if (!HMCCU_IsValidDatapoint ($hash, $ccutype, $ccuaddr, $dpt, 2));
if ($par =~ /^\?(.+)$/) {
$par = $1;
$value = shift @$a;
}
else {
my @parList = split(',', $par);
$value = (scalar(@parList) > 1) ? shift @$a : $par;
}
return HMCCU_SetError ($hash, "Usage: set $name $opt $par") if (!defined($value));
$rc = HMCCU_SetMultipleDatapoints ($hash, { "001.$ccuif.$ccuaddr.$dpt" => $value });
return HMCCU_SetError ($hash, min(0, $rc));
}
elsif ($opt =~ /^(pct|level|up|down)$/) {
return HMCCU_SetError ($hash, "Can't find LEVEL datapoint for device type $ccutype")
if (!HMCCU_IsValidDatapoint ($hash, $ccutype, $ccuaddr, "LEVEL", 2));
@ -457,15 +503,21 @@ sub HMCCUCHN_Set ($@)
elsif ($opt =~ /^(config|values)$/) {
my %parSets = ('config' => 'MASTER', 'values' => 'VALUES');
my $paramset = $parSets{$opt};
my $receiver = '';
return HMCCU_SetError ($hash, "No parameter specified")
if ((scalar keys %{$h}) < 1);
my $ccuobj = $ccuaddr;
my $p = shift @$a;
if (defined($p) && $p eq 'device') {
($ccuobj, undef) = HMCCU_SplitChnAddr ($ccuaddr);
$p = shift @$a;
if (defined($p)) {
if ($p eq 'device') {
($ccuobj, undef) = HMCCU_SplitChnAddr ($ccuaddr);
}
else {
$receiver = $p;
$paramset = 'LINK';
}
}
my $devDesc = HMCCU_GetDeviceDesc ($ioHash, $ccuobj, $ccuif);
@ -477,19 +529,7 @@ sub HMCCUCHN_Set ($@)
if ($paramset eq 'VALUES') {
($rc, $result) = HMCCU_SetMultipleParameters ($hash, $ccuaddr, $h);
}
else {
($rc, $result) = HMCCU_RPCRequest ($hash, "putParamset", $ccuaddr, $paramset, $h);
}
return HMCCU_SetError ($hash, min(0, $rc));
}
elsif ($opt eq 'link') {
return HMCCU_SetError ($hash, "No parameter specified")
if ((scalar keys %{$h}) < 1);
my @rcvList = ();
my $receiver = shift @$a;
if (defined($receiver)) {
elsif ($paramset eq 'LINK') {
if (exists($defs{$receiver}) && defined($defs{$receiver}->{TYPE})) {
my $clHash = $defs{$receiver};
if ($clHash->{TYPE} eq 'HMCCUDEV') {
@ -514,43 +554,26 @@ sub HMCCUCHN_Set ($@)
return HMCCU_SetError ($hash, "$receiver is not a link receiver of $name")
if (!HMCCU_IsValidReceiver ($ioHash, $ccuaddr, $ccuif, $receiver));
push @rcvList, $receiver;
($rc, $result) = HMCCU_RPCRequest ($hash, "putParamset", $ccuaddr, $receiver, $h);
}
else {
push @rcvList, HMCCU_GetReceivers ($ioHash, $ccuaddr, $ccuif);
}
my $devDesc = HMCCU_GetDeviceDesc ($ioHash, $ccuaddr, $ccuif);
return HMCCU_SetError ($hash, "Can't get device description")
if (!defined($devDesc));
return HMCCU_SetError ($hash, "Paramset LINK not supported by device or channel")
if ($devDesc->{PARAMSETS} !~ /LINK/);
foreach my $rcv (@rcvList) {
($rc, $result) = HMCCU_RPCRequest ($hash, "putParamset", $ccuaddr, $rcv, $h);
return HMCCU_SetError ($hash, $rc) if ($rc < 0);
($rc, $result) = HMCCU_RPCRequest ($hash, "putParamset", $ccuaddr, $paramset, $h);
}
return HMCCU_SetState ($hash, "OK");
return HMCCU_SetError ($hash, min(0, $rc));
}
elsif ($opt eq 'defaults') {
$rc = HMCCU_SetDefaults ($hash);
$rc = HMCCU_SetDefaultAttributes ($hash);
$rc = HMCCU_SetDefaults ($hash) if (!$rc);
return HMCCU_SetError ($hash, $rc == 0 ? "No default attributes found" : "OK");
}
else {
my $retmsg = "clear defaults:noArg";
if ($hash->{readonly} ne 'yes') {
$retmsg .= " config control datapoint rpcparameter";
if (scalar(@states) > 0) {
$retmsg .= ' toggle:noArg '.join (' ', map { $_.':noArg' } @states);
$retmsg .= " on-for-timer on-till"
if (HMCCU_IsValidDatapoint ($hash, $ccutype, $sc, "ON_TIME", 2));
}
$retmsg .= " pct up down level"
if (HMCCU_IsValidDatapoint ($hash, $ccutype, $cc, "LEVEL", 2));
$retmsg .= " stop"
if (HMCCU_IsValidDatapoint ($hash, $ccutype, $cc, "STOP", 2));
$retmsg .= " config control datapoint".$cmdList;
$retmsg .= ' toggle:noArg' if (scalar(@states) > 0);
$retmsg .= " on-for-timer on-till"
if (HMCCU_IsValidDatapoint ($hash, $ccutype, $sc, "ON_TIME", 2));
}
return AttrTemplate_Set ($hash, $retmsg, $name, $opt, @$a);
}
@ -746,11 +769,14 @@ sub HMCCUCHN_Get ($@)
Delete readings matching specified reading name expression. Default expression is '.*'.
Readings 'state' and 'control' are not deleted.
</li><br/>
<li><b>set &lt;name&gt; config [device] &lt;parameter&gt;=&lt;value&gt;[:&lt;type&gt;]</b><br/>
Set multiple config parameters (parameter set MASTER).
<li><b>set &lt;name&gt; config [device|&lt;receiver&gt;] &lt;parameter&gt;=&lt;value&gt;[:&lt;type&gt;]</b><br/>
Set multiple config parameters (parameter sets MASTER or LINK).
With option 'device' a parameter set of the device is set instead of the current channel.
Supports attribute 'ccuscaleval' for datapoints. Parameter <i>parameter</i> must be a valid
config parameter name. If <i>type</i> is not specified, it's taken from
config parameter name. Parameter <i>receiver</i> is the
name of a FHEM device of type HMCCUDEV or HMCCUCHN or a channel address or a CCU
channel name. For FHEM devices of type HMCCUDEV a <i>channel</i> number must be specified.
Parameter <i>parameter</i> must be a valid. If <i>type</i> is not specified, it's taken from
parameter set definition. The default <i>type</i> is STRING.
Valid types are STRING, BOOL, INTEGER, FLOAT, DOUBLE.
</li><br/>

9
fhem/contrib/HMCCU/FHEM/88_HMCCUDEV.pm
View File

@ -390,8 +390,13 @@ sub HMCCUDEV_Set ($@)
my $ccuflags = AttrVal ($name, 'ccuflags', 'null');
my $statevals = AttrVal ($name, 'statevals', '');
my ($sc, $sd, $cc, $cd) = HMCCU_GetSpecialDatapoints ($hash, '', '', '', '');
my $stateVals = HMCCU_GetStateValues ($hash, $cd, 2);
my %stateCmds = split (/[:,]/, $stateVals);
# Get additional commands (including state commands)
my $roleCmds = HMCCU_GetSpecialCommands ($hash, $cc);
# Get state values related to control command and datapoint
my $stateVals = HMCCU_GetStateValues ($hash, $roleCmds, $cd, 2);
my %stateCmds = split (/[:\s]/, $stateVals);
my @states = keys %stateCmds;
my $result = '';