Public/fhem-mirror
1
0
Fork 0
mirror of https://github.com/fhem/fhem-mirror.git synced 2024-06-17 05:40:11 +00:00
Code Issues Packages Projects Releases Wiki Activity
cc77516708
fhem-mirror/FHEM/31_MilightDevice.pm
mattwire 717b13f4e1 30_MilightBridge: Use new RemoveInternalTimer function 
git-svn-id: https://svn.fhem.de/fhem/trunk/fhem@16085 2b470e98-0d58-463d-a4d8-8e2adae1ed80
2018-02-04 18:35:23 +00:00

2586 lines
96 KiB
Perl
Raw Blame History

# $Id$
##############################################
#
# 31_MilightDevice.pm (Based on 32_WifiLight.pm by hermannj)
# FHEM module for MILIGHT lightbulbs. Supports RGB (untested), RGBW and White models.
# Author: Matthew Wire (mattwire)
#
# 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/>.
#
##############################################################################
package main;
use strict;
use warnings;
use IO::Handle;
use IO::Socket;
use IO::Select;
use Time::HiRes;
#use Math::Round ();
use Color;
use SetExtensions;
my %dim_values = (
0 => "dim_00",
1 => "dim_10",
2 => "dim_20",
3 => "dim_30",
4 => "dim_40",
5 => "dim_50",
6 => "dim_60",
7 => "dim_70",
8 => "dim_80",
9 => "dim_90",
10 => "dim_100",
);
# RGBW 3 byte commands. 3rd byte not required Bridge V3+
my @RGBWCmdsOn = ("\x45", "\x47", "\x49", "\x4B", "\x42"); # Byte 1 for setting On
my @RGBWCmdsOff = ("\x46", "\x48", "\x4A", "\x4C", "\x41"); # Byte 1 for setting Off
my @RGBWCmdsWT = ("\xC5", "\xC7", "\xC9", "\xCB", "\xC2"); # Byte 1 for setting WhiteMode
my @RGBWCmdsNt = ("\xC6", "\xC8", "\xCA", "\xCC", "\xC1"); # Byte 1 for setting NightMode
my $RGBWCmdBri = "\x4E"; # Byte 1 for setting brightness (Byte 2 specifies level (0x02-0x1B 25 steps)
my $RGBWCmdCol = "\x40"; # Byte 1 for setting color (Byte 2 specifies color value (0x00-0xFF (255 steps))
my $RGBWCmdDiscoUp = "\x4D"; # Byte 1 for setting discoMode Up
my $RGBWCmdDiscoInc = "\x44"; # Byte 1 for setting discoMode speed +
my $RGBWCmdDiscoDec = "\x43"; # Byte 1 for setting discoMode speed -
my $RGBWCmdEnd = "\x55"; # Byte 3
# White 3 byte commands.
my @WhiteCmdsOn = ("\x38", "\x3D", "\x37", "\x32", "\x35"); # Byte 1 for setting On
my @WhiteCmdsOff = ("\x3B", "\x33", "\x3A", "\x36", "\x39"); # Byte 1 for setting Off
my @WhiteCmdsOnFull = ("\xB8", "\xBD", "\xB7", "\xB2", "\xB5"); # Byte 1 for setting full brightness
my @WhiteCmdsNt = ("\xBB", "\xB3", "\xBA", "\xB6", "\xB9"); # Byte 1 for setting NightMode
my @WhiteCmdBriDn = ("\x34", "\x34", "\x34", "\x34", "\xB4"); # Byte 1 for setting Brightness down (11 steps, no direct setting)
my @WhiteCmdBriUp = ("\x3C", "\x3C", "\x3C", "\x3C", "\xBC"); # Byte 1 for setting Brightness up (11 steps, no direct setting)
my @WhiteCmdColDn = ("\x3F", "\x3F", "\x3F", "\x3F", "\xBF"); # Byte 1 for setting colour temp down
my @WhiteCmdColUp = ("\x3E", "\x3E", "\x3E", "\x3E", "\xBE"); # Byte 1 for setting colour temp up
my $WhiteCmdEnd = "\x55"; # Byte 3
sub MilightDevice_Initialize($)
{
my ($hash) = @_;
$hash->{DefFn} = "MilightDevice_Define";
$hash->{UndefFn} = "MilightDevice_Undef";
$hash->{ShutdownFn} = "MilightDevice_Undef";
$hash->{SetFn} = "MilightDevice_Set";
$hash->{GetFn} = "MilightDevice_Get";
$hash->{AttrFn} = "MilightDevice_Attr";
$hash->{NotifyFn} = "MilightDevice_Notify";
$hash->{AttrList} = "IODev dimStep defaultBrightness defaultRampOn " .
"defaultRampOff presets dimOffWhite:1,0 updateGroupDevices:1,0 " .
"restoreAtStart:1,0 colorCast gamma lightSceneParamsToSave " .
$readingFnAttributes;
FHEM_colorpickerInit();
}
#####################################
# Device State Icon for FHEMWEB: Shows a colour changing icon with dim level
sub MilightDevice_devStateIcon($)
{
my($hash) = @_;
$hash = $defs{$hash} if(ref($hash) ne 'HASH');
return undef if(!$hash);
return undef if($hash->{helper}->{group});
my $name = $hash->{NAME};
my $percent = ReadingsVal($name,"brightness","100");
my $s = $dim_values{MilightDevice_roundfunc($percent/10)};
# Return SVG coloured icon with toggle as default action
return ".*:light_light_$s@#".ReadingsVal($name, "rgb", "FFFFFF").":toggle"
if (($hash->{LEDTYPE} eq 'RGBW') || ($hash->{LEDTYPE} eq 'RGB'));
# Return SVG icon with toggle as default action (for White bulbs)
return ".*:light_light_$s:toggle";
}
#####################################
# Define Milight device
sub MilightDevice_Define($$)
{
my ($hash, $def) = @_;
my @args = split("[ \t][ \t]*", $def);
my ($name, $type, $ledtype, $iodev, $slot) = @args;
$hash->{INIT} = 0; # Set to 1 when lamp initialised (MilightDevice_Restore)
$hash->{LEDTYPE} = $ledtype;
$hash->{SLOT} = $slot;
$hash->{SLOTID} = $slot;
if($slot eq 'A') {
$hash->{SLOTID} = 9 if ($hash->{LEDTYPE} eq 'RGBW');
$hash->{SLOTID} = 5 if ($hash->{LEDTYPE} eq 'White');
$hash->{SLOTID} = 0 if ($hash->{LEDTYPE} eq 'RGB');
}
# Validate parameters
return "wrong syntax: define <name> MilightDevice <devType(RGB|RGBW|White)> <IODev> <slot>" if(@args < 5);
return "unknown LED type ($hash->{LEDTYPE}): choose one of RGB, RGBW, White" if ($hash->{LEDTYPE} !~ /RGBW|White|RGB/);
return "Invalid slot: Select one of 1..4 / A for White" if (($hash->{SLOTID} !~ /^\d*$/) || (($hash->{SLOT} ne 'A') && (($hash->{SLOT} < 1) || ($hash->{SLOT} > 4))) && ($hash->{LEDTYPE} eq 'White'));
return "Invalid slot: Select one of 5..8 / A for RGBW" if (($hash->{SLOTID} !~ /^\d*$/) || (($hash->{SLOT} ne 'A') && (($hash->{SLOT} < 5) || ($hash->{SLOT} > 8))) && ($hash->{LEDTYPE} eq 'RGBW'));
return "Invalid slot: Select 0 for RGB" if (($hash->{SLOTID} !~ /^\d*$/) || ($hash->{SLOTID} != 0 && $hash->{LEDTYPE} eq 'RGB'));
Log3 ($hash, 4, $name."_Define: $name $type $hash->{LEDTYPE} $iodev $hash->{SLOT}");
# Verify IODev is valid
AssignIoPort($hash, $iodev);
if(defined($hash->{IODev}->{NAME})) {
Log3 $name, 4, $name."_Define: I/O device is " . $hash->{IODev}->{NAME};
} else {
Log3 $name, 1, $name."_Define: no I/O device";
}
# Look for already defined device on IODev
if ($hash->{SLOT} ne 'A' && defined($hash->{IODev}->{$hash->{SLOT}}->{NAME}))
{
# If defined slot does not match current device name don't allow new definition. Redefining the same device is ok though.
#return "Slot $hash->{SLOT} already defined as $hash->{IODev}->{$hash->{SLOT}}->{NAME}" if ($hash->{IODev}->{$hash->{SLOT}}->{NAME} ne $name);
}
# Define device on IODev
if ($hash->{SLOT} ne 'A')
{
$hash->{IODev}->{$hash->{SLOT}}->{NAME} = $name;
#$hash->{IODev}->{$hash->{SLOT}}->{DEVNAME} = $name;
}
# Define Command Queue
my @cmdQueue = [];
$hash->{helper}->{cmdQueue} = \@cmdQueue;
my $baseCmds = "on off toggle dimup dimdown";
my $sharedCmds = "pair unpair restorePreviousState:noArg saveState:noArg restoreState:noArg";
my $rgbCmds = "hsv rgb:colorpicker,RGB hue:colorpicker,HUE,0,1,360 saturation:slider,0,100,100 preset";
$hash->{helper}->{COMMANDSET} = "$baseCmds discoModeUp:noArg discoSpeedUp:noArg discoSpeedDown:noArg night:noArg white:noArg toggleWhite:noArg $sharedCmds $rgbCmds"
if ($hash->{LEDTYPE} eq 'RGBW');
$hash->{helper}->{COMMANDSET} = "$baseCmds discoModeUp:noArg discoModeDown:noArg discoSpeedUp:noArg discoSpeedDown:noArg $sharedCmds $rgbCmds"
if ($hash->{LEDTYPE} eq 'RGB');
$hash->{helper}->{COMMANDSET} = "$baseCmds hsv ct:colorpicker,CT,3000,350,6500 night:noArg $sharedCmds"
if ($hash->{LEDTYPE} eq 'White');
my $defaultcommandset = $hash->{helper}->{COMMANDSET};
$hash->{helper}->{COMMANDSET} .= " dim:slider,0,".MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)).",100 brightness:slider,0,".MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)).",100";
# webCmds
if (!defined($attr{$name}{webCmd}))
{
$attr{$name}{webCmd} = 'on:off:dim:hue:night:rgb ffffff:rgb ff0000:rgb 00ff00:rgb 0000ff:rgb ffff00' if ($hash->{LEDTYPE} eq 'RGBW');
$attr{$name}{webCmd} = 'on:off:dim:hue:rgb ffffff:rgb ff0000:rgb 00ff00:rgb 0000ff:rgb ffff00' if ($hash->{LEDTYPE} eq 'RGB');
$attr{$name}{webCmd} = 'on:off:dim:ct:night' if ($hash->{LEDTYPE} eq 'White');
}
$hash->{helper}->{GAMMAMAP} = MilightDevice_CreateGammaMapping($hash, 1.0);
$hash->{helper}->{COLORMAP} = MilightDevice_ColorConverter($hash, split(',', "0,0,0,0,0,0"));
# Define devStateIcon
$attr{$name}{devStateIcon} = '{(MilightDevice_devStateIcon($name),"toggle")}' if(!defined($attr{$name}{devStateIcon}));
# Event on change reading
$attr{$name}{"event-on-change-reading"} = "state,transitionInProgress" if (!defined($attr{$name}{"event-on-change-reading"}));
# lightScene
if(!defined($attr{$name}{"lightSceneParamsToSave"}))
{
$attr{$name}{"lightSceneParamsToSave"} = "hsv" if (($hash->{LEDTYPE} eq 'RGBW')|| ($hash->{LEDTYPE} eq 'RGB'));
$attr{$name}{"lightSceneParamsToSave"} = "brightness" if ($hash->{LEDTYPE} eq 'White');
}
# IODev
$attr{$name}{IODev} = $hash->{IODev} if (!defined($attr{$name}{IODev}));
# restoreAtStart
if($slot eq 'A') {
$attr{$name}{"restoreAtStart"} = 0 if (!defined($attr{$name}{"restoreAtStart"}));
} else {
$attr{$name}{"restoreAtStart"} = 1 if (!defined($attr{$name}{"restoreAtStart"}));
}
return undef;
}
sub MilightDevice_Init($)
{
my ($hash) = @_;
my $name = $hash->{NAME};
if( AttrVal($hash->{NAME}, "gamma", "1.0") eq "1.0")
{
Log3 ($name, 5, $name." dimstep ".MilightDevice_roundfunc(100 / MilightDevice_DimSteps($hash))." / gamma 1.0");
} else {
$hash->{helper}->{COMMANDSET} =~ s/dim:slider,0,.*,100/dim:slider,0,1,100/g;
$hash->{helper}->{COMMANDSET} =~ s/brightness:slider,0,.*,100/brightness:slider,0,1,100/g;
Log3 $name, 5, $name." dimstep 1 / gamma ".AttrVal($hash->{NAME}, "gamma", "1.0");
$hash->{helper}->{GAMMAMAP} = MilightDevice_CreateGammaMapping($hash, AttrVal($hash->{NAME}, "gamma", "1.0"));
}
# Colormap / Commandsets
if (($hash->{LEDTYPE} eq 'RGBW') || ($hash->{LEDTYPE} eq 'RGB'))
{
my @a = split(',', "0,0,0,0,0,0");
if ( defined( $attr{$name}{colorCast} ) )
{
@a = split(',', AttrVal($hash->{NAME}, "colorCast", "0,0,0,0,0,0"));
@a = split(',', "0,0,0,0,0,0") unless (@a == 6);
foreach my $tc (@a)
{
@a = split(',', "0,0,0,0,0,0") unless ($tc =~ m/^\s*[\-]{0,1}[0-9]+[\.]{0,1}[0-9]*\s*$/g);
@a = split(',', "0,0,0,0,0,0") if (abs($tc) >= 30);
}
}
$hash->{helper}->{COLORMAP} = MilightDevice_ColorConverter($hash, @a);
}
return undef;
}
#####################################
# Undefine device
sub MilightDevice_Undef(@)
{
my ($hash,$args) = @_;
RemoveInternalTimer($hash);
# Remove slot on bridge
delete ($hash->{IODev}->{$hash->{SLOT}}->{NAME}) if ($hash->{SLOT} ne 'A');
return undef;
}
#####################################
# Set functions
sub MilightDevice_Set(@)
{
my ($hash, $name, $cmd, @args) = @_;
my $cnt = @args;
my $ramp = 0;
my $flags = "";
my $event = undef;
my $usage = "set $name ...";
if ($hash->{IODev}->{STATE} ne "ok" && $hash->{IODev}->{STATE} ne "Initialized") {
readingsSingleUpdate($hash, "state", "error", 1);
$flags = "q";
$args[2] = "" if(!defined($args[2]));
$args[2] .= "q" if ($args[2] !~ m/.*[qQ].*/);
# return SetExtensions($hash, $hash->{helper}->{COMMANDSET}, $name, $cmd, @args);
# IO error, we need to keep our current state settings!
}
# Commands that map to other commands
if ($cmd eq "toggle")
{
$cmd = ReadingsVal($name,"state","on") ne "off" ? "off" :"on";
}
elsif ($cmd eq "white")
{
$cmd = "saturation";
$args[0] = 0;
}
elsif ($cmd eq "toggleWhite")
{
$cmd = "saturation";
$args[0] = (ReadingsVal($name,"saturation",100) > 0) ? 0 : 100;
}
# Commands
if ($cmd eq 'on')
{
if (defined($args[0]))
{
return "Usage: set $name on [seconds(0..X)]" if ($args[0] !~ /^\d+$/);
$ramp = $args[0];
}
elsif (defined($attr{$name}{defaultRampOn}))
{
$ramp = $attr{$name}{defaultRampOn};
}
return MilightDevice_RGBW_On($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_DimOn($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White' && AttrVal($hash->{NAME}, "dimOffWhite", 0) == 1);
return MilightDevice_White_On($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_On($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGB');
}
elsif ($cmd eq 'off')
{
if (defined($args[0]))
{
return "Usage: set $name off [seconds(0..X)]" if ($args[0] !~ /^\d+$/);
$ramp = $args[0];
}
elsif (defined($attr{$name}{defaultRampOff}))
{
$ramp = $attr{$name}{defaultRampOff};
}
return MilightDevice_RGBW_Off($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_DimOff($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White' && AttrVal($hash->{NAME}, "dimOffWhite", 0) == 1);
return MilightDevice_White_Off($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_Off($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGB');
}
# Set HSV value
elsif ($cmd eq 'hsv')
{
$usage = "Usage: set $name hsv <h(0..360)>,<s(0..100)>,<v(0..100)> [seconds(0..x)] [flags(l=long path|q=don't clear queue)]";
$usage = "Usage: set $name hsv <h(3000=Warm..6500=Cool)>,<s(-)>,<v(0..100)> [seconds(0..x)] [flags(q=don't clear queue)]" if ($hash->{LEDTYPE} eq 'White');
return $usage if ($args[0] !~ /^(\d{1,4}),(\d{1,3}),(\d{1,3})$/);
my ($h, $s, $v) = ($1, $2, $3);
return "Invalid hue ($h): valid range 0..360" if (!(($h >= 0) && ($h <= 360)) && ($hash->{LEDTYPE} ne 'White'));
return "Invalid color temperature ($h): valid range 3000..6500" if (!(($h >= 3000) && ($h <= 6500)) && ($hash->{LEDTYPE} eq 'White'));
return "Invalid saturation ($s): valid range 0..100" if (!(($s >= 0) && ($s <= 100)) && ($hash->{LEDTYPE} ne 'White'));
return "Invalid brightness ($v): valid range 0..100" if !(($v >= 0) && ($v <= 100));
if (defined($args[1]))
{
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] > 0)); # Decimal value for ramp > 0
$ramp = $args[1];
}
if (defined($args[2]))
{
return $usage if ($args[2] !~ m/.*[lLqQ].*/); # Flags l=Long way round for transition, q=don't clear queue (add to end)
$flags = $args[2];
}
return MilightDevice_White_Transition($hash, $h, 0, $v, $ramp, $flags) if($hash->{LEDTYPE} eq 'White');
return MilightDevice_HSV_Transition($hash, $h, $s, $v, $ramp, $flags);
}
# Dim to a fixed percentage with transition if requested
elsif ($cmd eq 'dim' || $cmd eq 'brightness')
{
$usage = "Usage: set $name dim <percent(0..100)> [seconds(0..x)] [flags(l=long path|q=don't clear queue)]";
return $usage if (($args[0] !~ /^\d+$/) || ($args[0] < 0) || ($args[0] > 100)); # Decimal value for percent between 0..100
if (defined($args[1]))
{
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] > 0)); # Decimal value for ramp > 0
$ramp = $args[1];
}
if (defined($args[2]))
{
return $usage if ($args[2] !~ m/.*[lLqQ].*/); # Flags l=Long way round for transition, q=don't clear queue (add to end)
$flags = $args[2];
}
return MilightDevice_RGBW_Dim($hash, $args[0], $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_Dim($hash, $args[0], $ramp, $flags) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_Dim($hash, $args[0], $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGB');
}
# Set night mode
elsif ($cmd eq 'night')
{
if (defined($args[0]))
{
return "Usage: set $name night";
}
return MilightDevice_RGBW_Night($hash) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_Night($hash) if ($hash->{LEDTYPE} eq 'White');
}
# Set hue
elsif ($cmd eq 'hue')
{
$usage = "Usage: set $name hue <h(0..360)> [seconds(0..x)] [flags(l=long path|q=don't clear queue)]";
return $usage if (($args[0] !~ /^(\d+)$/) || ($args[0] < 0) || ($args[0] > 360));
if (defined($args[1]))
{
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] > 0)); # Decimal value for ramp > 0
$ramp = $args[1];
}
if (defined($args[2]))
{
return $usage if ($args[2] !~ m/.*[lLqQ].*/); # Flags l=Long way round for transition, q=don't clear queue (add to end)
$flags = $args[2];
}
my $sat = ReadingsVal($hash->{NAME}, "saturation", 100);
$sat = 100 if(ReadingsVal($hash->{NAME}, "saturation", 0) == 0);
return MilightDevice_HSV_Transition($hash, $args[0], $sat, ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36)), $ramp, $flags);
}
# Set color temperature
elsif ($cmd eq 'ct')
{
if (defined($args[0]))
{
return "Usage: set $name ct <3000=Warm..6500=Cool>" if (($args[0] !~ /^\d+$/) || ($args[0] < 2500 || $args[0] > 7000));
}
if (defined($args[1]))
{
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] > 0)); # Decimal value for ramp > 0
$ramp = $args[1];
}
if (defined($args[2]))
{
return $usage if ($args[2] !~ m/.*[lLqQ].*/); # Flags l=Long way round for transition, q=don't clear queue (add to end)
$flags = $args[2];
}
return MilightDevice_White_SetColourTemp($hash, $args[0], $ramp, $flags);
}
# Set RGB value
elsif( $cmd eq "rgb")
{
$usage = "Usage: set $name rgb RRGGBB [seconds(0..x)] [flags(l=long path|q=don't clear queue)]";
return $usage if ($args[0] !~ /^([0-9A-Fa-f]{1,2})([0-9A-Fa-f]{1,2})([0-9A-Fa-f]{1,2})$/);
my( $r, $g, $b ) = (hex($1), hex($2), hex($3)); #change to color.pm?
my( $h, $s, $v ) = Color::rgb2hsv($r/255.0,$g/255.0,$b/255.0);
$h = MilightDevice_roundfunc($h * 360);
$s = MilightDevice_roundfunc($s * 100);
$v = MilightDevice_roundfunc($v * 100);
if (defined($args[1]))
{
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] > 0)); # Decimal value for ramp > 0
$ramp = $args[1];
}
if (defined($args[2]))
{
return $usage if ($args[2] !~ m/.*[lLqQ].*/); # Flags l=Long way round for transition, q=don't clear queue (add to end)
$flags = $args[2];
}
return MilightDevice_HSV_Transition($hash, $h, $s, $v, $ramp, $flags);
}
# Dim up by 1 "dimStep" or by a percentage with transition if requested
elsif ($cmd eq 'dimup')
{
$usage = "Usage: set $name dimup [percent change(0..100)] [seconds(0..x)]";
my $percentChange = MilightDevice_roundfunc(100 / MilightDevice_DimSteps($hash)); # Default one dimStep
if (defined($args[0]))
{ # Percent change (0..100%)
return $usage if (($args[0] !~ /^\d+$/) || ($args[0] < 0) || ($args[0] > 100)); # Decimal value for percent between 0..100
$percentChange = $args[0]; # Percentage to change, will be converted in dev specific function
}
if (defined($args[1]))
{ # Seconds for transition (0..x)
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] >= 0)); # Decimal value for ramp > 0
$ramp = $args[1];
# Special case, if percent=100 adjust the ramp so it matches the actual amount required.
# Eg. start: 80%. ramp 5seconds. Amount change: 100-80=20. Ramp time req: 20/100*5 = 1second.
if ($percentChange == 100)
{
my $difference = $percentChange - ReadingsVal($hash->{NAME}, "brightness", 0);
$ramp = ($difference/100) * $ramp;
Log3 ($hash, 5, "$hash->{NAME}_Set: dimdown. Adjusted ramp to $ramp");
}
}
my $newBrightness = ReadingsVal($hash->{NAME}, "brightness", 0) + $percentChange;
$newBrightness = 100 if $newBrightness > 100;
return MilightDevice_RGBW_Dim($hash, $newBrightness, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_Dim($hash, $newBrightness, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_Dim($hash, $newBrightness, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGB');
}
# Dim down by 1 "dimStep" or by a percentage with transition if requested
elsif ($cmd eq 'dimdown')
{
$usage = "Usage: set $name dimdown [percent change(0..100)] [seconds(0..x)]";
my $percentChange = MilightDevice_roundfunc(100 / MilightDevice_DimSteps($hash)); # Default one dimStep
if (defined($args[0]))
{ # Percent change (0..100%)
return $usage if (($args[0] !~ /^\d+$/) || ($args[0] < 0) || ($args[0] > 100)); # Decimal value for percent between 0..100
$percentChange = $args[0]; # Percentage to change, will be converted in dev specific function
}
if (defined($args[1]))
{ # Seconds for transition (0..x)
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] >= 0)); # Decimal value for ramp > 0
$ramp = $args[1];
# Special case, if percent=100 adjust the ramp so it matches the actual amount required.
# Eg. start: 80%. ramp 5seconds. Amount change: 80. Ramp time req: 80/100*5 = 4second.
if ($percentChange == 100)
{
my $difference = ReadingsVal($hash->{NAME}, "brightness", 0);
$ramp = ($difference/100) * $ramp;
Log3 ($hash, 5, "$hash->{NAME}_Set: dimdown. Adjusted ramp to $ramp");
}
}
my $newBrightness = ReadingsVal($hash->{NAME}, "brightness", 0) - $percentChange;
$newBrightness = 0 if $newBrightness < 0;
return MilightDevice_RGBW_Dim($hash, $newBrightness, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_Dim($hash, $newBrightness, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_Dim($hash, $newBrightness, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGB');
}
elsif ($cmd eq 'saturation')
{
$usage = "Usage: set $name saturation <h(0..100)> [seconds(0..x)] [flags(q=don't clear queue)]";
return $usage if (($args[0] !~ /^\d+$/) || ($args[0] < 0) || ($args[0] > 100));
if (defined($args[1]))
{
return $usage if (($args[1] !~ /^\d+$/) && ($args[1] > 0)); # Decimal value for ramp > 0
$ramp = $args[1];
}
if (defined($args[2]))
{
return $usage if ($args[2] !~ m/.*[qQ].*/); # Flags q=don't clear queue (add to end)
$flags = $args[2];
}
return MilightDevice_HSV_Transition($hash, ReadingsVal($hash->{NAME}, "hue", 0), $args[0], ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36)), $ramp, $flags);
}
elsif ($cmd eq 'discoModeUp')
{
return MilightDevice_RGBW_DiscoModeStep($hash, 1);
}
elsif ($cmd eq 'discoModeDown')
{
return MilightDevice_RGBW_DiscoModeStep($hash, 0);
}
elsif ($cmd eq 'discoSpeedUp')
{
return MilightDevice_RGBW_DiscoModeSpeed($hash, 1);
}
elsif ($cmd eq 'discoSpeedDown')
{
return MilightDevice_RGBW_DiscoModeSpeed($hash, 0);
}
elsif ($cmd eq 'restorePreviousState')
{
# Restore the previous state (as store in previous* readings)
my ($h, $s, $v) = MilightDevice_HSVFromStr($hash, ReadingsVal($hash->{NAME}, "previousState", MilightDevice_HSVToStr($hash, 0, 0, 0)));
if($v eq 0)
{
if (defined($attr{$name}{defaultRampOff}))
{
$ramp = $attr{$name}{defaultRampOff};
}
return MilightDevice_RGBW_Off($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_DimOff($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White' && AttrVal($hash->{NAME}, "dimOffWhite", 0) == 1);
return MilightDevice_White_Off($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_Off($hash, $ramp, $flags) if ($hash->{LEDTYPE} eq 'RGB');
}
MilightDevice_HSV_Transition($hash, $h, $s, $v, 0, '');
return undef;
}
elsif ($cmd eq 'saveState')
{
# Save the hsv state as a string
readingsSingleUpdate($hash, "savedState", MilightDevice_HSVToStr($hash, ReadingsVal($hash->{NAME}, "hue", 0), ReadingsVal($hash->{NAME}, "saturation", 0), ReadingsVal($hash->{NAME}, "brightness", 0)), 1);
return undef;
}
elsif ($cmd eq 'restoreState')
{
my ($h, $s, $v) = MilightDevice_HSVFromStr($hash, ReadingsVal($hash->{NAME}, "savedState", MilightDevice_HSVToStr($hash, 0, 0, 0)));
return MilightDevice_HSV_Transition($hash, $h, $s, $v, 0, '');
}
elsif ($cmd eq 'preset')
{
my $preset = "+";
# Default to "preset +" if no args defined
if (defined($args[0]))
{
return "Usage: set $name preset <0..X|+>" if ($args[0] !~ /^(\d+|\+)$/);
$preset = $args[0];
}
# Get presets, if not defined default to 1 preset 0,0,100.
my @presets = split(/ /, AttrVal($hash->{NAME}, "presets", MilightDevice_HSVToStr($hash, 0, 0, 100)));
# Load the next preset (and loop back to the first) if "+" specified.
if ("$preset" eq "+")
{
$preset = (ReadingsVal($hash->{NAME}, "lastPreset", -1) + 1);
if ($#presets < $preset) { $preset = 0; }
}
return "No preset defined at index $preset" if ($#presets < $preset);
# Update reading and load preset
readingsSingleUpdate($hash, "lastPreset", $preset, 1);
my ($h, $s, $v) = MilightDevice_HSVFromStr($hash, $presets[$preset]);
return MilightDevice_HSV_Transition($hash, $h, $s, $v, 0, '');
}
elsif ($cmd eq 'pair')
{
if (defined($args[0]))
{
return "Usage: set $name pair [seconds(0..X)(default 3)]" if ($args[0] !~ /^\d+$/);
$ramp = $args[0];
}
else { $ramp = 3; } # Default pair for 3 seconds
MilightDevice_CmdQueue_Clear($hash);
return MilightDevice_RGBW_Pair($hash, $ramp) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_Pair($hash, $ramp) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_Pair($hash, $ramp) if ($hash->{LEDTYPE} eq 'RGB');
}
elsif ($cmd eq 'unpair')
{
if (defined($args[0]))
{
return "Usage: set $name unpair [seconds(0..X)(default 3)]" if ($args[0] !~ /^\d+$/);
$ramp = $args[0];
}
else { $ramp = 3; } # Default unpair for 3 seconds
MilightDevice_CmdQueue_Clear($hash);
return MilightDevice_RGBW_UnPair($hash, $ramp) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_UnPair($hash, $ramp) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_UnPair($hash, $ramp) if ($hash->{LEDTYPE} eq 'RGB');
}
return SetExtensions($hash, $hash->{helper}->{COMMANDSET}, $name, $cmd, @args);
}
#####################################
# Get functions
sub MilightDevice_Get(@)
{
my ($hash, @args) = @_;
my $name = $args[0];
return "$name: get needs at least one parameter" if(@args < 2);
my $cmd= $args[1];
if($cmd eq "rgb" || $cmd eq "RGB") {
return ReadingsVal($name, "rgb", "FFFFFF");
}
elsif($cmd eq "hsv") {
return MilightDevice_HSVToStr($hash, ReadingsVal($hash->{NAME}, "ct", 3000), 0, ReadingsVal($hash->{NAME}, "brightness", 0)) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_HSVToStr($hash, ReadingsVal($hash->{NAME}, "hue", 0), ReadingsVal($hash->{NAME}, "saturation", 0), ReadingsVal($hash->{NAME}, "brightness", 0));
}
return "Unknown argument $cmd, choose one of rgb:noArg hsv:noArg";
}
#####################################
# Attribute functions
sub MilightDevice_Attr(@)
{
my ($cmd, $device, $attribName, $attribVal) = @_;
my $hash = $defs{$device};
$attribVal = "" if (!defined($attribVal));
Log3 ($hash, 4, "$hash->{NAME}_Attr: Cmd: $cmd; Attribute: $attribName; Value: $attribVal");
if ($cmd eq 'set' && $attribName eq 'gamma')
{
return "gamma is required as numerical value with one decimal (eg. 0.5 or 2.2)" if ($attribVal !~ /^\d*\.\d*$/);
$hash->{helper}->{GAMMAMAP} = MilightDevice_CreateGammaMapping($hash, $attribVal);
if($attribVal ne "1.0")
{
$hash->{helper}->{COMMANDSET} =~ s/dim:slider,0,.*,100/dim:slider,0,1,100/g;
$hash->{helper}->{COMMANDSET} =~ s/brightness:slider,0,.*,100/brightness:slider,0,1,100/g;
}
}
# Allows you to modify the default number of dimSteps for a device
elsif ($cmd eq 'set' && $attribName eq 'dimStep')
{
return "dimStep is required as numerical value [1..100]" if ($attribVal !~ /^\d*$/) || (($attribVal < 1) || ($attribVal > 100));
}
# Allows you to set a default transition time for on/off
elsif ($cmd eq 'set' && (($attribName eq 'defaultRampOn') || ($attribName eq 'defaultRampOff')))
{
return "defaultRampOn/Off is required as numerical value [0..100]" if ($attribVal !~ /^[0-9]*\.?[0-9]*$/) || (($attribVal < 0) || ($attribVal > 100));
}
# List of presets in hsv separated by space. Loaded by set command preset X
elsif ($cmd eq 'set' && ($attribName eq 'presets'))
{
return "presets is required as space separated list of hsv(h,s,v) (eg. 0,0,100, 0,100,50)" if ($attribVal !~ /^[(\d{1,3}),(\d{1,3}),(\d{1,3})(?:$|\s)]*$/);
}
elsif ($cmd eq 'set' && $attribName eq 'colorCast')
{
return "colorCast: only works with RGB(W) devices" if ($hash->{LEDTYPE} eq 'White');
my @a = split(',', $attribVal);
my $msg = "colorCast: correction requires red, yellow, green ,cyan, blue, magenta (each in a range of -29 .. 29)";
return $msg unless (@a == 6);
foreach my $tc (@a)
{
return $msg unless ($tc =~ m/^\s*[\-]{0,1}[0-9]+[\.]{0,1}[0-9]*\s*$/g);
return $msg if (abs($tc) >= 30);
}
$hash->{helper}->{COLORMAP} = MilightDevice_ColorConverter($hash, @a);
#MilightDevice_RGB_ColorConverter($hash, @a);
if ($init_done && !(@{$hash->{helper}->{cmdQueue}} > 0))
{
my $hue = $hash->{READINGS}->{hue}->{VAL};
my $sat = $hash->{READINGS}->{saturation}->{VAL};
my $val = $hash->{READINGS}->{brightness}->{VAL};
return MilightDevice_RGBW_SetHSV($hash, $hue, $sat, $val, 1) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_RGB_SetHSV($hash, $hue, $sat, $val, 1) if ($hash->{LEDTYPE} eq 'RGB');
}
}
elsif ($cmd eq 'set' && $attribName eq 'defaultBrightness')
{
return "defaultBrighness: has to be between ".MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash))." and 100" if ($attribVal < MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)) || $attribVal > 100);
}
return undef;
}
#####################################
# Notify functions
sub MilightDevice_Notify(@)
{
my ($hash,$dev) = @_;
return MilightDevice_Restore($hash);
}
#####################################
# Restore HSV settings from readings.
# Called after initialization to synchronise lamp state with fhem.
sub MilightDevice_Restore(@)
{
my ($hash) = @_;
return if ($hash->{INIT});
if ($init_done)
{
return if (AttrVal($hash->{NAME}, "restoreAtStart", 0) == 0);
Log3 ($hash, 4, "$hash->{NAME}_Restore: Restoring saved HSV values");
$hash->{INIT} = 1;
# Initialize device
MilightDevice_Init($hash);
# Clear inProgress flag: MJW Do we still need to do this?
readingsSingleUpdate($hash, "transitionInProgress", 0, 1);
# Default to OFF if not defined
my ($hue, $sat, $val);
$hue = ReadingsVal($hash->{NAME}, "hue", 0);
$sat = ReadingsVal($hash->{NAME}, "saturation", 0);
$val = ReadingsVal($hash->{NAME}, "brightness", 0);
# Restore state
return MilightDevice_RGBW_SetHSV($hash, $hue, $sat, $val, 1) if ($hash->{LEDTYPE} eq 'RGBW');
return MilightDevice_White_SetHSV($hash, $hue, $sat, $val, 1) if ($hash->{LEDTYPE} eq 'White');
return MilightDevice_RGB_SetHSV($hash, $hue, $sat, $val, 1) if ($hash->{LEDTYPE} eq 'RGB');
}
}
###############################################################################
# device specific controller functions RGB
# LED Strip or bulb, no white, controller V2+. No longer manufactured Jan2014
###############################################################################
sub MilightDevice_RGB_Pair(@)
{
my ($hash, $numSeconds) = @_;
$numSeconds = 3 if (($numSeconds || 0) == 0);
Log3 ($hash, 4, "$hash->{NAME}_RGB_Pair: RGB LED slot $hash->{SLOT} pair $numSeconds s");
# DISCO SPEED FASTER 0x25 (SYNC/PAIR RGB Bulb within 2 seconds of Wall Switch Power being turned ON)
my $ctrl = "\x25\x00\x55";
for (my $i = 0; $i < $numSeconds; $i++)
{
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 1000, undef);
}
return undef;
}
#####################################
sub MilightDevice_RGB_UnPair(@)
{
my ($hash) = @_;
my $numSeconds = 8;
Log3 ($hash, 4, "$hash->{NAME}_RGB_UnPair: RGB LED slot $hash->{SLOT} unpair $numSeconds s");
# DISCO SPEED FASTER 0x25 (SYNC/PAIR RGB Bulb within 2 seconds of Wall Switch Power being turned ON)
my $ctrl = "\x25\x00\x55";
for (my $i = 0; $i < $numSeconds; $i++)
{
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
}
return undef;
}
#####################################
sub MilightDevice_RGB_On(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
my $v = AttrVal($hash->{NAME}, "defaultBrightness", 36);
Log3 ($hash, 4, "$hash->{NAME}_RGB_On: RGB slot $hash->{SLOT} set on $ramp");
# Switch on with same brightness it was switched off with, or max if undefined.
if (ReadingsVal($hash->{NAME}, "state", "off") eq "off")
{
$v = ReadingsVal($hash->{NAME}, "brightness_on", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
else
{
$v = ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
# When turning on, make sure we request at least minimum dim step.
if ($v < MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)))
{
$v = MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash));
}
return MilightDevice_RGB_Dim($hash, $v, $ramp, $flags);
}
#####################################
sub MilightDevice_RGB_Off(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_RGB_Off: RGB slot $hash->{SLOT} set off $ramp");
# Store value of brightness before turning off
# "on" will be of the form "on 50" where 50 is current dimlevel
if (ReadingsVal($hash->{NAME}, "state", "off") ne "off")
{
readingsSingleUpdate($hash, "brightness_on", ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36)), 1);
MilightDevice_BridgeDevices_Update($hash, "brightness_on") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
# Dim down to min brightness then send off command (avoid flicker on turn on)
MilightDevice_RGB_Dim($hash, MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)), $ramp, $flags);
return MilightDevice_RGB_Dim($hash, 0, 0, 'qP');
}
else
{
# If we are already off just send the off command again
return MilightDevice_RGB_Dim($hash, 0, 0, 'P');
}
}
#####################################
sub MilightDevice_RGB_Dim(@)
{
my ($hash, $level, $ramp, $flags) = @_;
my $h = ReadingsVal($hash->{NAME}, "hue", 0);
my $s = ReadingsVal($hash->{NAME}, "saturation", 0);
Log3 ($hash, 4, "$hash->{NAME}_RGB_Dim: RGB slot $hash->{SLOT} dim $level $ramp $flags");
return MilightDevice_HSV_Transition($hash, $h, $s, $level, $ramp, $flags);
}
#####################################
sub MilightDevice_RGB_SetHSV(@)
{
my ($hash, $hue, $sat, $val, $repeat) = @_;
Log3 ($hash, 4, "$hash->{NAME}_RGB_setHSV: RGB slot $hash->{SLOT} set h:$hue, s:$sat, v:$val");
$sat = 100;
MilightDevice_SetHSV_Readings($hash, $hue, $sat, $val);
# apply gamma correction
my $gammaVal = $hash->{helper}->{GAMMAMAP}[$val];
# convert to device specs
my ($cv, $cl, $wl) = MilightDevice_RGB_ColorConverter($hash, $hue, $sat, $gammaVal);
Log3 ($hash, 4, "$hash->{NAME}_RGB_setHSV: RGB slot $hash->{SLOT} set levels: $cv, $cl, $wl");
$repeat = 1 if (!defined($repeat));
# On first load, colorLevel won't be defined, define it.
$hash->{helper}->{colorLevel} = $cl if (!defined($hash->{helper}->{colorLevel}));
# NOTE: All commands sent twice for reliability (it's udp with no feedback)
if (($wl < 1) && ($cl < 1)) # off
{
# if no white or colour switch off
IOWrite($hash, "\x21\x00\x55"); # switch off
$hash->{helper}->{colorLevel} = 0;
}
else # on
{
if (($wl > 0) || ($cl > 0)) # Colour/White on
{
IOWrite($hash, "\x22\x00\x55"); # switch on
IOWrite($hash, "\x20".chr($cv)."\x55"); # set color
if ($repeat eq 1) {
IOWrite($hash, "\x22\x00\x55"); # switch on
IOWrite($hash, "\x20".chr($cv)."\x55"); # set color
}
# cl decrease
if ($hash->{helper}->{colorLevel} > $cl)
{
for (my $i=$hash->{helper}->{colorLevel}; $i > $cl; $i--)
{
IOWrite($hash, "\x24\x00\x55"); # brightness down
$hash->{helper}->{colorLevel} = $i - 1;
}
}
# cl increase
if ($hash->{helper}->{colorLevel} < $cl)
{
for (my $i=$hash->{helper}->{colorLevel}; $i < $cl; $i++)
{
IOWrite($hash, "\x23\x00\x55"); # brightness up
$hash->{helper}->{colorLevel} = $i + 1;
}
}
}
}
return undef;
}
#####################################
sub MilightDevice_RGB_ColorConverter(@)
{
my ($hash, $h, $s, $v) = @_;
my $color = $hash->{helper}->{COLORMAP}[$h % 360];
# there are 0..9 dim level, setup correction
my $valueSpread = MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash));
my $totalVal = MilightDevice_roundfunc($v / $valueSpread);
# saturation 100..50: color full, white increase. 50..0 white full, color decrease
my $colorVal = ($s >= 50) ? $totalVal : int(($s / 50 * $totalVal) +0.5);
my $whiteVal = ($s >= 50) ? int(((100-$s) / 50 * $totalVal) +0.5) : $totalVal;
return ($color, $colorVal, $whiteVal);
}
###############################################################################
# RGBW device specific: Bridge V3+ only.
# Available as GU10, E14, E27, B22, led strip controller...
###############################################################################
sub MilightDevice_RGBW_Pair(@)
{
my ($hash, $numSeconds) = @_;
$numSeconds = 3 if (($numSeconds || 0) == 0);
Log3 ($hash, 4, "$hash->{NAME}_RGBW_Pair: $hash->{LEDTYPE} at $hash->{CONNECTION}, slot $hash->{SLOT}: pair $numSeconds");
# find my slot and get my group-all-on cmd
my $ctrl = @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd;
# Send on command once a second
for (my $i = 0; $i < $numSeconds; $i++)
{
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 1000, undef);
}
return undef;
}
#####################################
sub MilightDevice_RGBW_UnPair(@)
{
my ($hash, $numSeconds, $releaseFromSlot) = @_;
$numSeconds = 3 if (($numSeconds || 0) == 0);
Log3 ($hash, 4, "$hash->{NAME}_RGBW_UnPair: $hash->{LEDTYPE} at $hash->{CONNECTION}, slot $hash->{SLOT}: unpair $numSeconds");
# find my slot and get my group-all-on cmd
my $ctrl = @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd;
# Send on command every 200ms
for (my $i = 0; $i < $numSeconds; $i++)
{
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
}
return undef;
}
#####################################
sub MilightDevice_RGBW_On(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
my $v = AttrVal($hash->{NAME}, "defaultBrightness", 36);
Log3 ($hash, 4, "$hash->{NAME}_RGBW_On: Set ON; Ramp: $ramp");
# Switch on with same brightness it was switched off with, or max if undefined.
if (ReadingsVal($hash->{NAME}, "state", "off") eq "off" || ReadingsVal($hash->{NAME}, "state", "off") eq "night")
{
$v = ReadingsVal($hash->{NAME}, "brightness_on", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
else
{
$v = ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
# When turning on, make sure we request at least minimum dim step.
if ($v < MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)))
{
$v = MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash));
}
return MilightDevice_RGBW_Dim($hash, $v, $ramp, $flags);
}
#####################################
sub MilightDevice_RGBW_Off(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_RGBW_Off: Set OFF; Ramp: $ramp");
# Store value of brightness before turning off
# "on" will be of the form "on 50" where 50 is current dimlevel
if (ReadingsVal($hash->{NAME}, "state", "off") ne "off" && ReadingsVal($hash->{NAME}, "state", "off") ne "night")
{
readingsSingleUpdate($hash, "brightness_on", ReadingsVal($hash->{NAME}, "brightness", 0), 1);
MilightDevice_BridgeDevices_Update($hash, "brightness_on") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
# Dim down to min brightness then send off command (avoid flicker on turn on)
MilightDevice_RGBW_Dim($hash, MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)), $ramp, $flags);
return MilightDevice_RGBW_Dim($hash, 0, 0, 'qP');
}
else
{
# If we are already off just send the off command again
return MilightDevice_RGBW_Dim($hash, 0, 0, 'P');
}
}
#####################################
sub MilightDevice_RGBW_Night(@)
{
my ($hash) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_RGBW_Night: Set NIGHTMODE");
if(ReadingsVal($hash->{NAME}, "state", "off") ne "night") {
if (ReadingsVal($hash->{NAME}, "brightness", 0) > 0)
{
readingsSingleUpdate($hash, "brightness_on", ReadingsVal($hash->{NAME}, "brightness", 4), 1);
MilightDevice_BridgeDevices_Update($hash, "brightness_on") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
}
IOWrite($hash, @RGBWCmdsOff[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd); # off
}
IOWrite($hash, @RGBWCmdsNt[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd); # night
readingsSingleUpdate($hash, "state", "night", 1);
MilightDevice_BridgeDevices_Update($hash, "state") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
return undef;
}
#####################################
sub MilightDevice_RGBW_Dim(@)
{
my ($hash, $v, $ramp, $flags) = @_;
my $h = ReadingsVal($hash->{NAME}, "hue", 0);
my $s = ReadingsVal($hash->{NAME}, "saturation", 0);
Log3 ($hash, 4, "$hash->{NAME}_RGBW_Dim: Brightness: $v; Ramp: $ramp; Flags: ". $flags || '');
return MilightDevice_HSV_Transition($hash, $h, $s, $v, $ramp, $flags);
}
#####################################
sub MilightDevice_RGBW_SetHSV(@)
{
my ($hash, $hue, $sat, $val, $repeat) = @_;
my ($cl, $wl);
$repeat = 1 if (!defined($repeat));
my $cv = $hash->{helper}->{COLORMAP}[$hue % 360];
#check dim levels to decide wether to change color or brightness first
my $dimup = 0;
$dimup = 1 if($val > ReadingsVal($hash->{NAME}, "brightness", 100));
# apply gamma correction
my $gammaVal = $hash->{helper}->{GAMMAMAP}[$val];
# brightness 2..27 (x02..x1b) | 25 dim levels
my $cf = MilightDevice_roundfunc((($gammaVal / 100) * MilightDevice_DimSteps($hash)) + 1);
if ($sat < 20)
{
$wl = $cf;
$cl = 0;
$sat = 0;
}
else
{
$cl = $cf;
$wl = 0;
$sat = 100;
}
Log3 ($hash, 5, "MilightDevice_RGBW_SetHSV: h:$hue s:$sat v:$val / cv:$cv wl:$wl cl:$cl ");
# Set readings in FHEM
MilightDevice_SetHSV_Readings($hash, $hue, $sat, $val);
# NOTE: All commands sent twice for reliability (it's udp with no feedback)
# Off is shifted to "2" above so check for < 2
if (($wl < 2) && ($cl < 2)) # off
{
IOWrite($hash, @RGBWCmdsOff[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd); # group off
IOWrite($hash, @RGBWCmdsOff[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if ($repeat eq 1); # group off
$hash->{helper}->{whiteLevel} = 0;
$hash->{helper}->{colorLevel} = 0;
}
else # on
{
if ($wl > 0) # white
{
IOWrite($hash, @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if (($wl > 0) || ($cl > 0)); # group on
IOWrite($hash, @RGBWCmdsWT[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd); # white
IOWrite($hash, $RGBWCmdBri.chr($wl).$RGBWCmdEnd); # brightness
if ($repeat eq 1) {
IOWrite($hash, @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if (($wl > 0) || ($cl > 0)); # group on
IOWrite($hash, @RGBWCmdsWT[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd); # white
IOWrite($hash, $RGBWCmdBri.chr($wl).$RGBWCmdEnd); # brightness
}
}
elsif ($cl > 0) # color
{
IOWrite($hash, @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if (($wl > 0) || ($cl > 0)); # group on
if($dimup)
{
IOWrite($hash, $RGBWCmdCol.chr($cv).$RGBWCmdEnd); # color
IOWrite($hash, $RGBWCmdBri.chr($cl).$RGBWCmdEnd); # brightness
} else {
IOWrite($hash, $RGBWCmdBri.chr($cl).$RGBWCmdEnd); # brightness
IOWrite($hash, $RGBWCmdCol.chr($cv).$RGBWCmdEnd); # color
}
if ($repeat eq 1) {
IOWrite($hash, @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if (($wl > 0) || ($cl > 0)); # group on
if($dimup)
{
IOWrite($hash, $RGBWCmdCol.chr($cv).$RGBWCmdEnd); # color
IOWrite($hash, $RGBWCmdBri.chr($cl).$RGBWCmdEnd); # brightness
} else {
IOWrite($hash, $RGBWCmdBri.chr($cl).$RGBWCmdEnd); # brightness
IOWrite($hash, $RGBWCmdCol.chr($cv).$RGBWCmdEnd); # color
}
}
}
$hash->{helper}->{colorValue} = $cv;
$hash->{helper}->{colorLevel} = $cl;
$hash->{helper}->{whiteLevel} = $wl;
}
return undef;
}
####################################
# RGB and RGBW types
sub MilightDevice_RGBW_DiscoModeStep(@)
{
my ($hash, $step) = @_;
MilightDevice_CmdQueue_Clear($hash);
$step = 0 if ($step < 0);
$step = 1 if ($step > 1);
# Set readings in FHEM
MilightDevice_SetDisco_Readings($hash, $step, ReadingsVal($hash->{NAME}, 'discoSpeed', 5));
# NOTE: Only sending commands once, because it makes changes on each successive command
IOWrite($hash, @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if (($hash->{LEDTYPE} eq 'RGBW')); # group on
IOWrite($hash, "\x22\x00\x55") if (($hash->{LEDTYPE} eq 'RGB')); # switch on
if ($step == 1)
{
IOWrite($hash, $RGBWCmdDiscoUp."\x00".$RGBWCmdEnd) if (($hash->{LEDTYPE} eq 'RGBW')); # discoMode step up
IOWrite($hash, "\x27\x00\x55") if (($hash->{LEDTYPE} eq 'RGB')); # discoMode step up
}
elsif ($step == 0)
{
IOWrite($hash, "\x28\x00\x55") if (($hash->{LEDTYPE} eq 'RGB')); # discoMode step down
# There is no discoMode step down for RGBW
}
return undef;
}
#####################################
# RGB and RGBW types
sub MilightDevice_RGBW_DiscoModeSpeed(@)
{
my ($hash, $speed) = @_;
MilightDevice_CmdQueue_Clear($hash);
$speed = 0 if ($speed < 0);
$speed = 1 if ($speed > 1);
# Set readings in FHEM
MilightDevice_SetDisco_Readings($hash, ReadingsVal($hash->{NAME}, 'discoMode', 1), $speed);
# NOTE: Only sending commands once, because it makes changes on each successive command
IOWrite($hash, @RGBWCmdsOn[$hash->{SLOTID} -5]."\x00".$RGBWCmdEnd) if (($hash->{LEDTYPE} eq 'RGBW')); # group on
IOWrite($hash, "\x22\x00\x55") if (($hash->{LEDTYPE} eq 'RGB')); # switch on
if ($speed == 1)
{
IOWrite($hash, $RGBWCmdDiscoInc."\x00".$RGBWCmdEnd) if ($hash->{LEDTYPE} eq 'RGBW'); # discoMode speed up
IOWrite($hash, "\x25\x00\x55") if ($hash->{LEDTYPE} eq 'RGB'); # discoMode speed up
}
elsif ($speed == 0)
{
IOWrite($hash, $RGBWCmdDiscoDec."\x00".$RGBWCmdEnd) if ($hash->{LEDTYPE} eq 'RGBW'); # discoMode speed down
IOWrite($hash, "\x26\x00\x55") if ($hash->{LEDTYPE} eq 'RGB'); # discoMode speed down
}
return undef;
}
###############################################################################
# White device specific: Warm/Cold White with Dim - Bridge V2+
###############################################################################
sub MilightDevice_White_Pair(@)
{
my ($hash, $numSeconds) = @_;
$numSeconds = 3 if (($numSeconds || 0) == 0);
Log3 ($hash, 4, "$hash->{NAME}_White_Pair: $hash->{LEDTYPE} at $hash->{CONNECTION}, slot $hash->{SLOT}: pair $numSeconds");
# find my slot and get my group-all-on cmd
my $ctrl = @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd;
# Send on command once a second
for (my $i = 0; $i < $numSeconds; $i++)
{
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 1000, undef);
}
return undef;
}
#####################################
sub MilightDevice_White_UnPair(@)
{
my ($hash, $numSeconds, $releaseFromSlot) = @_;
$numSeconds = 3 if (($numSeconds || 0) == 0);
Log3 ($hash, 4, "$hash->{NAME}_White_UnPair: $hash->{LEDTYPE} at $hash->{CONNECTION}, slot $hash->{SLOT}: unpair $numSeconds");
# find my slot and get my group-all-on cmd
my $ctrl = @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd;
for (my $i = 0; $i < $numSeconds; $i++)
{
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
}
return undef;
}
#####################################
sub MilightDevice_White_On(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
my $v = AttrVal($hash->{NAME}, "defaultBrightness", 36);
Log3 ($hash, 4, "$hash->{NAME}_White_On: Set ON: Ramp: $ramp");
# Switch on with same brightness it was switched off with, or max if undefined.
if (ReadingsVal($hash->{NAME}, "state", "off") eq "off" || ReadingsVal($hash->{NAME}, "state", "off") eq "night")
{
$v = ReadingsVal($hash->{NAME}, "brightness_on", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
else
{
$v = ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
# When turning on, make sure we request at least minimum dim step.
if ($v < MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)))
{
$v = MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash));
}
return MilightDevice_White_Dim($hash, $v, $ramp, $flags);
}
#####################################
sub MilightDevice_White_Off(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_White_Off: Set OFF; Ramp: $ramp");
# Store value of brightness before turning off
# "on" will be of the form "on 50" where 50 is current dimlevel
if (ReadingsVal($hash->{NAME}, "state", "off") ne "off" && ReadingsVal($hash->{NAME}, "state", "off") ne "night")
{
if (ReadingsVal($hash->{NAME}, "brightness", 0) > 0)
{
readingsSingleUpdate($hash, "brightness_on", ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36)), 1);
MilightDevice_BridgeDevices_Update($hash, "brightness_on") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
}
# Dim down to min brightness then send off command (avoid flicker on turn on)
MilightDevice_White_Dim($hash, MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)), $ramp, $flags);
return MilightDevice_White_Dim($hash, 0, 0, 'q');
}
else
{
# If we are already off just send the off command again
return MilightDevice_White_Dim($hash, 0, 0, 'P');
}
}
#####################################
sub MilightDevice_White_DimOff(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_White_DimOff: Set OFF; Ramp: $ramp");
if (ReadingsVal($hash->{NAME}, "brightness", 0) > 0)
{
readingsSingleUpdate($hash, "brightness_on", ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36)), 1);
MilightDevice_BridgeDevices_Update($hash, "brightness_on") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
}
for (my $i = 0; $i < 12; $i++)
{
IOWrite($hash, @WhiteCmdBriDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
}
IOWrite($hash, @WhiteCmdsOff[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
return MilightDevice_White_Dim($hash, 0, 0, 'q');
}
#####################################
sub MilightDevice_White_DimOn(@)
{
my ($hash, $ramp, $flags) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_White_DimOn: Set ON; Ramp: $ramp");
my $v = AttrVal($hash->{NAME}, "defaultBrightness", 36);
if (ReadingsVal($hash->{NAME}, "state", "off") eq "off" || ReadingsVal($hash->{NAME}, "state", "off") eq "night")
{
$v = ReadingsVal($hash->{NAME}, "brightness_on", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
else
{
$v = ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36));
}
# When turning on, make sure we request at least minimum dim step.
if ($v < MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)))
{
$v = MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash));
}
MilightDevice_White_Dim($hash, $v, $ramp, $flags);
for (my $i = 0; $i < ($v/(100/MilightDevice_DimSteps($hash))); $i++)
{
#IOWrite($hash, @WhiteCmdBriUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
}
#$ctrl = @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd;
#MilightDevice_CmdQueue_Add($hash, undef, undef, undef, $ctrl, 200, undef);
#return MilightDevice_White_Dim($hash, 0, 0, 'q');
}
#####################################
sub MilightDevice_White_Night(@)
{
my ($hash) = @_;
my $name = $hash->{NAME};
Log3 ($hash, 4, "$hash->{NAME}_White_NIGHT: Set NIGHTMODE");
if(ReadingsVal($hash->{NAME}, "state", "off") ne "night")
{
if (ReadingsVal($hash->{NAME}, "brightness", 0) > 0)
{
readingsSingleUpdate($hash, "brightness_on", ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36)), 1);
MilightDevice_BridgeDevices_Update($hash, "brightness_on") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
}
IOWrite($hash, @WhiteCmdsOff[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # off
}
IOWrite($hash, @WhiteCmdsNt[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # night
readingsSingleUpdate($hash, "state", "night", 1);
MilightDevice_BridgeDevices_Update($hash, "state") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
return undef;
}
#####################################
sub MilightDevice_White_Dim(@)
{
my ($hash, $level, $ramp, $flags) = @_;
Log3 ($hash, 4, "$hash->{NAME}_White_Dim: Brightness: $level; Ramp: $ramp; Flags: $flags");
return MilightDevice_HSV_Transition($hash, ReadingsVal($hash->{NAME}, "ct", 3000), 0, $level, $ramp, $flags);
}
#####################################
# $hue is colourTemperature, $val is brightness
sub MilightDevice_White_SetHSV(@)
{
my ($hash, $hue, $sat, $val, $repeat) = @_;
my $name = $hash->{NAME};
$repeat = 1 if (!defined($repeat));
# Validate brightness
$val = 100 if ($val > 100);
$val = 0 if ($val < 0);
# Validate colour temperature
$hue = 6500 if ($hue > 6500);
$hue = 3000 if ($hue < 3000);
my $oldHueStep = MilightDevice_White_ct_hwValue($hash, ReadingsVal($hash->{NAME}, "ct", 6500));
my $newHueStep = MilightDevice_White_ct_hwValue($hash, $hue);
$hue = MilightDevice_White_ct_hwValue($hash, $newHueStep);
# Set colour temperature
if ($oldHueStep != $newHueStep)
{
IOWrite($hash, @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on
if ($oldHueStep > $newHueStep)
{
Log3 ($hash, 4, "$hash->{NAME}_setColourTemp: Decrease from $oldHueStep to $newHueStep");
for (my $i=$oldHueStep; $i > $newHueStep; $i--)
{
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # Cooler (colourtemp up)
}
}
elsif ($oldHueStep < $newHueStep)
{
Log3 ($hash, 4, "$hash->{NAME}_setColourTemp: Increase from $oldHueStep to $newHueStep");
for (my $i=$oldHueStep; $i < $newHueStep; $i++)
{
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # Warmer (colourtemp down)
}
}
if(AttrVal($hash->{NAME}, "dimOffWhite", 0) == 1)
{
if($newHueStep == 1)
{
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
}
elsif($newHueStep == 11)
{
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
}
}
}
# apply gamma correction
my $gammaVal = $hash->{helper}->{GAMMAMAP}[$val];
# Calculate brightness hardware value (10 steps / 11 positions for white)
my $maxWl = (100 / MilightDevice_DimSteps($hash));
my $wl = MilightDevice_roundfunc($gammaVal / $maxWl);
# On first load, whiteLevel won't be defined, define it.
$hash->{helper}->{whiteLevel} = $wl if (!defined($hash->{helper}->{whiteLevel}));
if (ReadingsVal($hash, "brightness", 0) > 0)
{
# We are transitioning from on to off so store new value of wl and stop brightness up/down being triggered below
$hash->{helper}->{whiteLevel} = $wl;
}
# Store new values for colourTemperature and Brightness
MilightDevice_SetHSV_Readings($hash, $hue, 0, $val);
# Make sure we actually send off command if we should be off
if ($wl == 0)
{
IOWrite($hash, @WhiteCmdsOff[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group off
IOWrite($hash, @WhiteCmdsOff[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd) if ($repeat eq 1); # group off
Log3 ($hash, 4, "$hash->{NAME}_White_setHSV: OFF");
}
elsif ($wl == $maxWl)
{
IOWrite($hash, @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on
IOWrite($hash, @WhiteCmdsOnFull[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on full
if ($repeat eq 1) {
IOWrite($hash, @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on
IOWrite($hash, @WhiteCmdsOnFull[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on full
}
Log3 ($hash, 4, "$hash->{NAME}_White_setHSV: Full Brightness");
}
else
{
# Not off or MAX brightness, so make sure we are on
IOWrite($hash, @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on
IOWrite($hash, @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd) if ($repeat eq 1); # group on
if ($hash->{helper}->{whiteLevel} > $wl)
{
# Brightness level should be decreased
Log3 ($hash, 4, "$hash->{NAME}_White_setHSV: Brightness decrease from $hash->{helper}->{whiteLevel} to $wl");
for (my $i=$hash->{helper}->{whiteLevel}; $i > $wl; $i--)
{
IOWrite($hash, @WhiteCmdBriDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # brightness down
$hash->{helper}->{whiteLevel} = $i - 1;
}
}
elsif ($hash->{helper}->{whiteLevel} < $wl)
{
# Brightness level should be increased
$hash->{helper}->{whiteLevel} = 1 if ($hash->{helper}->{whiteLevel} == 0);
Log3 ($hash, 4, "$hash->{NAME}_White_setHSV: Brightness increase from $hash->{helper}->{whiteLevel} to $wl");
for (my $i=$hash->{helper}->{whiteLevel}; $i < $wl; $i++)
{
IOWrite($hash, @WhiteCmdBriUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # brightness up
$hash->{helper}->{whiteLevel} = $i + 1;
}
}
else
{
Log3 ($hash, 4, "$hash->{NAME}_White_setHSV: ON");
}
}
$hash->{helper}->{whiteLevel} = $wl;
return undef;
}
#####################################
sub MilightDevice_White_SetColourTemp(@)
{
# $hue is colourTemperature (1-11), $val is brightness (0-100%)
my ($hash, $hue) = @_;
my $name = $hash->{NAME};
MilightDevice_CmdQueue_Clear($hash);
# Save old value of ct
my $oldHue = MilightDevice_White_ct_hwValue($hash, ReadingsVal($hash->{NAME}, "ct", 6500));
# Store new values for colourTemperature and Brightness
MilightDevice_SetHSV_Readings($hash, $hue, 0, ReadingsVal($hash->{NAME}, "brightness", AttrVal($hash->{NAME}, "defaultBrightness", 36) ) );
# Validate colourTemperature (11 steps)
# 3000-6500 (350 per step) Warm-White to Cool White
# Maps backwards 1=6500 11=3000
$hue = MilightDevice_White_ct_hwValue($hash, $hue);
Log3 ($hash, 4, "$hash->{NAME}_setColourTemp: $oldHue to $hue");
# Set colour temperature
if ($oldHue != $hue)
{
IOWrite($hash, @WhiteCmdsOn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # group on
if ($oldHue > $hue)
{
Log3 ($hash, 4, "$hash->{NAME}_setColourTemp: Decrease from $oldHue to $hue");
for (my $i=$oldHue; $i > $hue; $i--)
{
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # Cooler (colourtemp up)
}
}
elsif ($oldHue < $hue)
{
Log3 ($hash, 4, "$hash->{NAME}_setColourTemp: Increase from $oldHue to $hue");
for (my $i=$oldHue; $i < $hue; $i++)
{
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd); # Warmer (colourtemp down)
}
}
}
if(AttrVal($hash->{NAME}, "dimOffWhite", 0) == 1)
{
if($hue == 1)
{
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColDn[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
}
elsif($hue == 11)
{
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
IOWrite($hash, @WhiteCmdColUp[$hash->{SLOTID} -1]."\x00".$WhiteCmdEnd);
}
}
return undef;
}
# Convert from 3000-6500 colourtemperature to hardware value
sub MilightDevice_White_ct_hwValue(@)
{
my ($hash, $ct) = @_;
# Couldn't get switch statement to work so using if
if ($ct == 11) { return 3000; }
elsif ($ct == 10) { return 3350; }
elsif ($ct == 9) { return 3700; }
elsif ($ct == 8) { return 4050; }
elsif ($ct == 7) { return 4400; }
elsif ($ct == 6) { return 4750; }
elsif ($ct == 5) { return 5100; }
elsif ($ct == 4) { return 5450; }
elsif ($ct == 3) { return 5800; }
elsif ($ct == 2) { return 6150; }
elsif ($ct == 1) { return 6500; }
elsif ($ct < 3350) { return 11; }
elsif ($ct < 3700) { return 10; }
elsif ($ct < 4050) { return 9; }
elsif ($ct < 4400) { return 8; }
elsif ($ct < 4750) { return 7; }
elsif ($ct < 5100) { return 6; }
elsif ($ct < 5450) { return 5; }
elsif ($ct < 5800) { return 4; }
elsif ($ct < 6150) { return 3; }
elsif ($ct < 6500) { return 2; }
return 1;
}
###############################################################################
# Device independent routines
###############################################################################
sub MilightDevice_HSVFromStr(@)
{
# Convert HSV values from string in format "h,s,v"
my ($hash, @args) = @_;
if ((!defined($args[0])) || ($args[0] !~ /^(\d{1,4}),(\d{1,3}),(\d{1,3})$/))
{
Log3 ($hash, 3, "MilightDevice_HSVFromStr: Could not parse h,s,v values from $args[0]");
return (0, 0, 0);
}
Log3 ($hash, 5, "MilightDevice_HSVFromStr: Parsed hsv string: h:$1,s:$2,v:$3");
return ($1, $2, $3);
}
#####################################
sub MilightDevice_HSVToStr(@)
{
# Convert HSV values to string in format "h,s,v"
my ($hash, $h, $s, $v) = @_;
$h=0 if (!defined($h));
$s=0 if (!defined($s));
$v=0 if (!defined($v));
Log3 ($hash, 5, "MilightDevice_HSVToStr: h:$h,s:$s,v:$v");
return "$h,$s,$v";
}
#####################################
sub MilightDevice_ValidateHSV(@)
{
# Validate and return valid values for HSV
my ($hash, $h, $s, $v) = @_;
$h = 0 if ($h < 0);
$h = 360 if ($h > 360 && $hash->{LEDTYPE} ne 'White');
$h = 3000 if ($h < 3000 && $hash->{LEDTYPE} eq 'White');
$h = 6500 if ($h > 6500);
$s = 0 if ($s < 0);
$s = 100 if ($s > 100);
$v = 0 if ($v < 0);
$v = 100 if ($v > 100);
return ($h, $s, $v);
}
#####################################
# Return number of steps for each type of bulb
# White: 11 steps (step = 9.1)
# RGB: 9 steps (step = 11)
# RGBW: 25 steps (step = 4)
sub MilightDevice_DimSteps(@)
{
my ($hash) = @_;
return AttrVal($hash->{NAME}, "dimStep", 25) if ($hash->{LEDTYPE} eq 'RGBW');
return AttrVal($hash->{NAME}, "dimStep", 11) if ($hash->{LEDTYPE} eq 'White');
return AttrVal($hash->{NAME}, "dimStep", 9) if ($hash->{LEDTYPE} eq 'RGB');
}
#####################################
# Return number of colour steps for each type of bulb
# White: 11 steps (this is colour temperature)
# RGB: 255 steps (not mentioned in API?)
# RGBW: 255 steps
sub MilightDevice_ColourSteps(@)
{
my ($hash) = @_;
return 255 if ($hash->{LEDTYPE} eq 'RGBW');
return 11 if ($hash->{LEDTYPE} eq 'White');
return 255 if ($hash->{LEDTYPE} eq 'RGB');
}
#####################################
# dispatcher
sub MilightDevice_SetHSV(@)
{
my ($hash, $hue, $sat, $val, $repeat) = @_;
MilightDevice_RGBW_SetHSV($hash, $hue, $sat, $val, $repeat) if ($hash->{LEDTYPE} eq 'RGBW');
MilightDevice_White_SetHSV($hash, $hue, $sat, $val, $repeat) if ($hash->{LEDTYPE} eq 'White');
MilightDevice_RGB_SetHSV($hash, $hue, $sat, $val, $repeat) if ($hash->{LEDTYPE} eq 'RGB');
return undef;
}
#####################################
sub MilightDevice_HSV_Transition(@)
{
my ($hash, $hue, $sat, $val, $ramp, $flags) = @_;
my ($hueFrom, $satFrom, $valFrom, $timeFrom)=0;
# Clear command queue if flag "q" not specified
MilightDevice_CmdQueue_Clear($hash) if ($flags !~ m/.*[qQ].*/);
# if queue in progress set start vals to last cached hsv target, else set start to actual hsv
if (@{$hash->{helper}->{cmdQueue}} > 0)
{
$hueFrom = $hash->{helper}->{targetHue};
$satFrom = $hash->{helper}->{targetSat};
$valFrom = $hash->{helper}->{targetVal};
$timeFrom = $hash->{helper}->{targetTime};
$hueFrom = 0 if(!defined($hueFrom));
$satFrom = 100 if(!defined($satFrom));
$valFrom = 0 if(!defined($valFrom));
$timeFrom = 0 if(!defined($timeFrom));
Log3 ($hash, 5, "$hash->{NAME}_HSV_Transition: Prepare Start (cached): $hueFrom,$satFrom,$valFrom@".$timeFrom);
}
else
{
$hueFrom = ReadingsVal($hash->{NAME}, "hue", 0);
$satFrom = ReadingsVal($hash->{NAME}, "saturation", 0);
$valFrom = ReadingsVal($hash->{NAME}, "brightness", 0);
$timeFrom = gettimeofday();
Log3 ($hash, 5, "$hash->{NAME}_HSV_Transition: Prepare Start (actual): $hueFrom,$satFrom,$valFrom@".$timeFrom);
if ($flags !~ m/.*[pP].*/ and ($hash->{LEDTYPE} eq 'RGB') || ($hash->{LEDTYPE} eq 'RGBW'))
{
# Store previous state if different to requested state
if (($hueFrom != $hue) || ($satFrom != $sat) || ($valFrom != $val))
{
readingsSingleUpdate($hash, "previousState", MilightDevice_HSVToStr($hash, $hueFrom, $satFrom, $valFrom),1);
}
}
}
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Current: $hueFrom,$satFrom,$valFrom");
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Set: $hue,$sat,$val; Ramp: $ramp; Flags: ". $flags);
# Store target vales
$hash->{helper}->{targetHue} = $hue;
$hash->{helper}->{targetSat} = $sat;
$hash->{helper}->{targetVal} = $val;
# if there is no ramp we don't need transition
if (($ramp || 0) == 0)
{
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Set: $hue,$sat,$val; No Ramp");
$hash->{helper}->{targetTime} = $timeFrom;
return MilightDevice_CmdQueue_Add($hash, $hue, $sat, $val, undef, 0, undef);
}
# calculate the left and right turn length based
# startAngle +360 -endAngle % 360 = counter clock
# endAngle +360 -startAngle % 360 = clockwise
my $hueTo = ($hue == 0) ? 1 : ($hue == 360) ? 359 : $hue;
my $fadeLeft = ($hueFrom + 360 - $hue) % 360;
my $fadeRight = ($hue + 360 - $hueFrom) % 360;
my $direction = ($fadeLeft <=> $fadeRight); # -1 = counterclock, +1 = clockwise
$direction = ($direction == 0)?1:$direction; # in dupt cw
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Colour rotation: cc(-1): $fadeLeft, cw(+1): $fadeRight; Shortest: $direction;");
$direction *= -1 if ($flags =~ m/.*[lL].*/); # reverse if long path desired (flag l or L is set)
my $rotation = ($direction == 1)?$fadeRight:$fadeLeft; # angle of hue rotation in based on flags
my $sFade = abs($sat - $satFrom);
my $vFade = abs($val - $valFrom);
# No transition, so set immediately and ignore ramp setting
if ($rotation == 0 && $sFade == 0 && $vFade == 0)
{
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Unchanged. Set: $hue,$sat,$val; Ignoring Ramp");
$hash->{helper}->{targetTime} = $timeFrom;
return MilightDevice_CmdQueue_Add($hash, $hue, $sat, $val, undef, 0, undef);
}
my ($stepWidth, $steps, $maxSteps, $hueToSet, $hueStep, $satToSet, $satStep, $valToSet, $valStep);
# Calculate stepWidth
if ($rotation >= ($sFade || $vFade))
{
# Transition based on Hue, so max steps = colourSteps
$stepWidth = ($ramp * 1000 / $rotation); # how long is one step (set hsv) in ms based on hue
$maxSteps = MilightDevice_ColourSteps($hash);
}
elsif ($sFade >= ($rotation || $vFade))
{
# Transition based on Saturation, so max steps = 2 (devices don't support sat, so set to 0 or 100 mostly)
$stepWidth = ($ramp * 1000 / $sFade); # how long is one step (set hsv) in ms based on sat
$maxSteps = 2;
}
else
{
# Transition based on Brightness, so max steps = dimSteps
$stepWidth = ($ramp * 1000 / $vFade); # how long is one step (set hsv) in ms based on val
$maxSteps = MilightDevice_DimSteps($hash);
}
# Calculate number of steps, limit to max number (no point running more if they are the same)
$steps = int($ramp * 1000 / $stepWidth);
if ($steps > $maxSteps)
{
$stepWidth *= ($steps/$maxSteps);
$steps = $maxSteps;
}
# Calculate number of steps, limit to max number (no point running more if they are the same)
$steps = int($ramp * 1000 / $stepWidth);
if ($steps > $maxSteps)
{
$stepWidth *= ($steps/$maxSteps);
$steps = $maxSteps;
}
# Calculate minimum stepWidth
# Min bridge delay as specified by Bridge * 3 (eg. 100*3=300ms).
# On average min 3 commands need to be sent per step (eg. Group On; Mode; Brightness;) so this gets it approximately right
my $minStepWidth = $hash->{IODev}->{INTERVAL} * 3;
$stepWidth = $minStepWidth if ($stepWidth < $minStepWidth); # Make sure we have min stepWidth
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Steps: $steps; Step Interval(ms): $stepWidth");
# Calculate hue step
$hueToSet = $hueFrom; # Start at current hue
$hueStep = $rotation / $steps * $direction;
# Calculate saturation step
$satToSet = $satFrom; # Start at current saturation
$satStep = ($sat - $satFrom) / $steps;
# Calculate brightness step
$valToSet = $valFrom; # Start at current brightness
$valStep = ($val - $valFrom) / $steps;
for (my $i=1; $i <= $steps; $i++)
{
$hueToSet += $hueStep; # Increment new hue by step (negative step decrements)
$hueToSet -= 360 if ($hueToSet > 360); #handle turn over zero
$hueToSet += 360 if ($hueToSet < 0);
$satToSet += $satStep; # Increment new saturation by step (negative step decrements)
$valToSet += $valStep; # Increment new brightness by step (negative step decrements)
Log3 ($hash, 4, "$hash->{NAME}_HSV_Transition: Add to Queue: h:".($hueToSet).", s:".($satToSet).", v:".($valToSet)." ($i/$steps)");
MilightDevice_CmdQueue_Add($hash, MilightDevice_roundfunc($hueToSet), MilightDevice_roundfunc($satToSet), MilightDevice_roundfunc($valToSet), undef, $stepWidth, $timeFrom + (($i-1) * $stepWidth / 1000) );
}
# Set target time for completion of sequence.
# This may be slightly higher than what was requested since $stepWidth > minDelay (($steps * $stepWidth) > $ramp)
$hash->{helper}->{targetTime} = $timeFrom + ($steps * $stepWidth / 1000);
Log3 ($hash, 5, "$hash->{NAME}_HSV_Transition: TargetTime: $hash->{helper}->{targetTime}");
return undef;
}
#####################################
sub MilightDevice_White_Transition(@)
{
my ($hash, $ct, $sat, $val, $ramp, $flags) = @_;
my ($ctFrom, $valFrom, $timeFrom)=0;
# Clear command queue if flag "q" not specified
MilightDevice_CmdQueue_Clear($hash) if ($flags !~ m/.*[qQ].*/);
# if queue in progress set start vals to last cached hsv target, else set start to actual hsv
if (@{$hash->{helper}->{cmdQueue}} > 0)
{
$ctFrom = $hash->{helper}->{targetCt};
$valFrom = $hash->{helper}->{targetVal};
$timeFrom = $hash->{helper}->{targetTime};
$ctFrom = 3000 if(!defined($ctFrom));
$valFrom = 0 if(!defined($valFrom));
$timeFrom = 0 if(!defined($timeFrom));
Log3 ($hash, 5, "$hash->{NAME}_White_Transition: Prepare Start (cached): $ctFrom,$valFrom@".$timeFrom);
}
else
{
$ctFrom = ReadingsVal($hash->{NAME}, "ct", 3000);
$valFrom = ReadingsVal($hash->{NAME}, "brightness", 0);
$timeFrom = gettimeofday();
Log3 ($hash, 5, "$hash->{NAME}_White_Transition: Prepare Start (actual): $ctFrom,$valFrom@".$timeFrom);
if ($flags !~ m/.*[pP].*/)
{
# Store previous state if different to requested state
if (($ctFrom != $ct) || ($valFrom != $val))
{
readingsSingleUpdate($hash, "previousState", MilightDevice_HSVToStr($hash, $ctFrom, 0, $valFrom),1);
}
}
}
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Current: $ctFrom,$valFrom");
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Set: $ct,$val; Ramp: $ramp; Flags: ". $flags);
# Store target vales
$hash->{helper}->{targetCt} = $ct;
$hash->{helper}->{targetVal} = $val;
# if there is no ramp we don't need transition
if (($ramp || 0) == 0)
{
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Set: $ct,$val; No Ramp");
$hash->{helper}->{targetTime} = $timeFrom;
return MilightDevice_CmdQueue_Add($hash, $ct, 0, $val, undef, 0, undef);
}
my $vFade = abs($val - $valFrom);
my $ctFade = abs($ct - $ctFrom);
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Colour temp: $ctFade, Brightness: $vFade;");
# No transition, so set immediately and ignore ramp setting
if ($ctFade == 0 && $vFade == 0)
{
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Unchanged. Set: $ct,0,$val; Ignoring Ramp");
$hash->{helper}->{targetTime} = $timeFrom;
return MilightDevice_CmdQueue_Add($hash, $ct, 0, $val, undef, 0, undef);
}
my ($stepWidth, $steps, $maxSteps, $ctToSet, $ctStep, $valToSet, $valStep);
# Calculate stepWidth
if ($ctFade >= $vFade)
{
# Transition based on ct, so max steps = colourSteps
$stepWidth = ($ramp * 1000 / $ctFade /100); # how long is one step (set hsv) in ms based on ct
$maxSteps = MilightDevice_ColourSteps($hash);
}
else
{
# Transition based on Brightness, so max steps = dimSteps
$stepWidth = ($ramp * 1000 / $vFade); # how long is one step (set hsv) in ms based on val
$maxSteps = MilightDevice_DimSteps($hash);
}
# Calculate number of steps, limit to max number (no point running more if they are the same)
$steps = int($ramp * 1000 / $stepWidth);
if ($steps > $maxSteps)
{
$stepWidth *= ($steps/$maxSteps);
$steps = $maxSteps;
}
# Calculate number of steps, limit to max number (no point running more if they are the same)
$steps = int($ramp * 1000 / $stepWidth);
if ($steps > $maxSteps)
{
$stepWidth *= ($steps/$maxSteps);
$steps = $maxSteps;
}
# Calculate minimum stepWidth
# Min bridge delay as specified by Bridge * 3 (eg. 100*3=300ms).
# On average min 3 commands need to be sent per step (eg. Group On; Mode; Brightness;) so this gets it approximately right
my $minStepWidth = $hash->{IODev}->{INTERVAL} * 3;
$stepWidth = $minStepWidth if ($stepWidth < $minStepWidth); # Make sure we have min stepWidth
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Steps: $steps; Step Interval(ms): $stepWidth");
# Calculate hue step
$ctToSet = $ctFrom; # Start at current hue
$ctStep = ($ct - $ctFrom) / $steps;
# Calculate brightness step
$valToSet = $valFrom; # Start at current brightness
$valStep = ($val - $valFrom) / $steps;
for (my $i=1; $i <= $steps; $i++)
{
$ctToSet += $ctStep; # Increment new hue by step (negative step decrements)
$valToSet += $valStep; # Increment new brightness by step (negative step decrements)
Log3 ($hash, 4, "$hash->{NAME}_White_Transition: Add to Queue: ct:".(int($ctToSet)).", s:0, v:".(int($valToSet))." ($i/$steps)");
MilightDevice_CmdQueue_Add($hash, MilightDevice_roundfunc($ctToSet), 0, MilightDevice_roundfunc($valToSet), undef, $stepWidth, $timeFrom + (($i-1) * $stepWidth / 1000) );
}
# Set target time for completion of sequence.
# This may be slightly higher than what was requested since $stepWidth > minDelay (($steps * $stepWidth) > $ramp)
$hash->{helper}->{targetTime} = $timeFrom + ($steps * $stepWidth / 1000);
Log3 ($hash, 5, "$hash->{NAME}_White_Transition: TargetTime: $hash->{helper}->{targetTime}");
return undef;
}
#####################################
sub MilightDevice_SetHSV_Readings(@)
{
my ($hash, $hue, $sat, $val, $val_on) = @_;
my $name = $hash->{NAME};
readingsBeginUpdate($hash); # Start update readings
# Store requested values
readingsBulkUpdate($hash, "brightness", $val);
# Store on brightness so we can turn on at a set brightness
readingsBulkUpdate($hash, "brightness_on", $val_on);
if (($hash->{LEDTYPE} eq 'RGB') || ($hash->{LEDTYPE} eq 'RGBW'))
{
# Store previous state if different to requested state
my $prevHue = ReadingsVal($hash->{NAME}, "hue", 0);
my $prevSat = ReadingsVal($hash->{NAME}, "saturation", 0);
my $prevVal = ReadingsVal($hash->{NAME}, "brightness", 0);
if (($prevHue != $hue) || ($prevSat != $sat) || ($prevVal != $val))
{
readingsBulkUpdate($hash, "previousState", MilightDevice_HSVToStr($hash, $prevHue, $prevSat, $prevVal)) if ReadingsVal($hash->{NAME}, "transitionInProgress", 1) eq 0;
}
readingsBulkUpdate($hash, "saturation", $sat);
readingsBulkUpdate($hash, "hue", $hue);
readingsBulkUpdate($hash, "hsv", MilightDevice_HSVToStr($hash, $hue,$sat,$val));
# Calc RGB values from HSV
my ($r,$g,$b) = Color::hsv2rgb($hue/360.0,$sat/100.0,$val/100.0);
$r *=255; $g *=255; $b*=255;
# Store values
readingsBulkUpdate($hash, "rgb", sprintf("%02X%02X%02X",$r,$g,$b)); # Int to Hex convert
readingsBulkUpdate($hash, "discoMode", 0);
readingsBulkUpdate($hash, "discoSpeed", 0);
}
elsif ($hash->{LEDTYPE} eq 'White')
{
readingsBulkUpdate($hash, "ct", $hue);
readingsBulkUpdate($hash, "hsv", MilightDevice_HSVToStr($hash, $hue,0,$val));
}
readingsBulkUpdate($hash, "state", "on $val") if ($val > 1);
readingsBulkUpdate($hash, "state", "off") if ($val < 2);
readingsEndUpdate($hash, 1);
MilightDevice_BridgeDevices_Update($hash, "bulk") if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1);
}
#####################################
sub MilightDevice_SetDisco_Readings(@)
{
# Step/Speed can be "1" or "0" when active
my ($hash, $step, $speed) = @_;
my $name = $hash->{NAME};
if (($hash->{LEDTYPE} eq 'RGBW') || ($hash->{LEDTYPE} eq 'RGB'))
{
my $discoMode = ReadingsVal($hash->{NAME}, "discoMode", 0);
$discoMode = "on";
my $discoSpeed = ReadingsVal($hash->{NAME}, "discoSpeed", 5);
$discoSpeed = "-" if ($speed == 0);
$discoSpeed = "+" if ($speed == 1);
readingsBeginUpdate($hash);
readingsBulkUpdate($hash, "discoMode", $step);
readingsBulkUpdate($hash, "discoSpeed", $speed);
readingsEndUpdate($hash, 1);
if ($hash->{SLOT} eq 'A' && AttrVal($hash->{NAME}, "updateGroupDevices", 0) == 1)
{
MilightDevice_BridgeDevices_Update($hash, "discoMode");
MilightDevice_BridgeDevices_Update($hash, "discoSpeed");
}
}
}
#####################################
sub MilightDevice_ColorConverter(@)
{
my ($hash, $cr, $cy, $cg, $cc, $cb, $cm) = @_;
my @colorMap;
my $adjRed = 0 + $cr;
my $adjYellow = 60 + $cy;
my $adjGreen = 120 + $cg;
my $adjCyan = 180 + $cc;
my $adjBlue = 240 + $cb;
my $adjLilac = 300 + $cm;
my $devRed = 176; # (0xB0)
#my $devYellow = 128; # (0x80)
my $devYellow = 144;
my $devGreen = 96; # (0x60)
#my $devCyan = 48; # (0x30)
my $devCyan = 56;
my $devBlue = 16; # (0x10)
my $devLilac = 224; # (0xE0)
my $i= 360;
# red to yellow
$adjRed += 360 if ($adjRed < 0); # in case of negative adjustment
$devRed += 256 if ($devRed < $devYellow);
$adjYellow += 360 if ($adjYellow < $adjRed);
for ($i = $adjRed; $i <= $adjYellow; $i++)
{
$colorMap[$i % 360] = ($devRed - int((($devRed - $devYellow) / ($adjYellow - $adjRed) * ($i - $adjRed)) +0.5)) % 255;
Log3 ($hash, 5, "$hash->{NAME}_ColorConverter: create colormap h: ".($i % 360)." d: ".$colorMap[$i % 360]);
}
#yellow to green
$devYellow += 256 if ($devYellow < $devGreen);
$adjGreen += 360 if ($adjGreen < $adjYellow);
for ($i = $adjYellow; $i <= $adjGreen; $i++)
{
$colorMap[$i % 360] = ($devYellow - int((($devYellow - $devGreen) / ($adjGreen - $adjYellow) * ($i - $adjYellow)) +0.5)) % 255;
Log3 ($hash, 5, "$hash->{NAME}_ColorConverter: create colormap h: ".($i % 360)." d: ".$colorMap[$i % 360]);
}
#green to cyan
$devGreen += 256 if ($devGreen < $devCyan);
$adjCyan += 360 if ($adjCyan < $adjGreen);
for ($i = $adjGreen; $i <= $adjCyan; $i++)
{
$colorMap[$i % 360] = ($devGreen - int((($devGreen - $devCyan) / ($adjCyan - $adjGreen) * ($i - $adjGreen)) +0.5)) % 255;
Log3 ($hash, 5, "$hash->{NAME}_ColorConverter: create colormap h: ".($i % 360)." d: ".$colorMap[$i % 360]);
}
#cyan to blue
$devCyan += 256 if ($devCyan < $devCyan);
$adjBlue += 360 if ($adjBlue < $adjCyan);
for ($i = $adjCyan; $i <= $adjBlue; $i++)
{
$colorMap[$i % 360] = ($devCyan - int((($devCyan - $devBlue) / ($adjBlue - $adjCyan) * ($i - $adjCyan)) +0.5)) % 255;
Log3 ($hash, 5, "$hash->{NAME}_ColorConverter: create colormap h: ".($i % 360)." d: ".$colorMap[$i % 360]);
}
#blue to lilac
$devBlue += 256 if ($devBlue < $devLilac);
$adjLilac += 360 if ($adjLilac < $adjBlue);
for ($i = $adjBlue; $i <= $adjLilac; $i++)
{
$colorMap[$i % 360] = ($devBlue - int((($devBlue - $devLilac) / ($adjLilac - $adjBlue) * ($i- $adjBlue)) +0.5)) % 255;
Log3 ($hash, 5, "$hash->{NAME}_ColorConverter: create colormap h: ".($i % 360)." d: ".$colorMap[$i % 360]);
}
#lilac to red
$devLilac += 256 if ($devLilac < $devRed);
$adjRed += 360 if ($adjRed < $adjLilac);
for ($i = $adjLilac; $i <= $adjRed; $i++)
{
$colorMap[$i % 360] = ($devLilac - int((($devLilac - $devRed) / ($adjRed - $adjLilac) * ($i - $adjLilac)) +0.5)) % 255;
Log3 ($hash, 5, "$hash->{NAME}_ColorConverter: create colormap h: ".($i % 360)." d: ".$colorMap[$i % 360]);
}
return \@colorMap;
}
#####################################
sub MilightDevice_CreateGammaMapping(@)
{
my ($hash, $gamma) = @_;
#original wifilight gamma was inverted
$gamma = 1/$gamma;
my @gammaMap;
$gammaMap[0] = 0;
for (my $i = 1; $i <= 100; $i += 1)
{
my $correction = ($i / 100) ** (1 / $gamma);
$gammaMap[$i] = $correction * 100;
$gammaMap[$i] = MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)) if($gammaMap[$i] < MilightDevice_roundfunc(100/MilightDevice_DimSteps($hash)));
Log3 ($hash, 5, "$hash->{NAME} create gammamap v-in: ".$i.", v-out: $gammaMap[$i]");
}
return \@gammaMap;
}
###############################################################################
# Device Command Queue
# Triggers commands for long running transitions for a device
###############################################################################
sub MilightDevice_CmdQueue_Add(@)
{
my ($hash, $hue, $sat, $val, $ctrl, $delay, $targetTime) = @_;
my $cmd;
# Validate input
($hue, $sat, $val) = MilightDevice_ValidateHSV($hash, $hue, $sat, $val);
$cmd->{hue} = $hue;
$cmd->{sat} = $sat;
$cmd->{val} = $val;
$cmd->{ctrl} = $ctrl;
$cmd->{delay} = $delay;
$cmd->{targetTime} = $targetTime;
$cmd->{inProgess} = 0;
push @{$hash->{helper}->{cmdQueue}}, $cmd;
my $hexStr = defined($cmd->{ctrl})? unpack("H*", $cmd->{ctrl} || '') : "";
Log3 ($hash, 4, "$hash->{NAME}_CmdQueue_Add: h: ".(defined($cmd->{hue})? $cmd->{hue}: "")."; s: ".(defined($cmd->{sat})? $cmd->{sat}: "")."; v: ".(defined($cmd->{val})? $cmd->{val}: "")."; Ctrl $hexStr; TargetTime: ".(defined($cmd->{targetTime})? $cmd->{targetTime}: "")."; QLen: ".@{$hash->{helper}->{cmdQueue}});
my $actualCmd = @{$hash->{helper}->{cmdQueue}}[0];
# sender busy ?
if(defined($actualCmd))
{
return undef if (ref($actualCmd) ne 'HASH');
return undef if (!defined($actualCmd->{inProgess}));
return undef if (($actualCmd->{inProgess} || 0) == 1);
}
return MilightDevice_CmdQueue_Exec($hash);
}
#####################################
sub MilightDevice_CmdQueue_Exec(@)
{
my ($hash) = @_;
RemoveInternalTimer($hash);
#if ($hash->{IODev}->{STATE} ne "ok" && $hash->{IODev}->{STATE} ne "Initialized") {
# InternalTimer(gettimeofday() + 60, "MilightDevice_CmdQueue_Exec", $hash, 0);
# return undef;
#}
my $actualCmd = @{$hash->{helper}->{cmdQueue}}[0];
# transmission complete, remove
shift @{$hash->{helper}->{cmdQueue}} if ($actualCmd->{inProgess});
# next in queue
$actualCmd = @{$hash->{helper}->{cmdQueue}}[0];
my $nextCmd = @{$hash->{helper}->{cmdQueue}}[1];
# return if no more elements in queue
if (!defined($actualCmd->{inProgess}))
{
readingsSingleUpdate($hash, "transitionInProgress", 0, 1); # Clear transitionInProgress flag
return undef;
}
readingsSingleUpdate($hash, "transitionInProgress", 1, 1); # Set transitionInProgress flag
# drop frames if next frame is already scheduled for given time. do not drop if it is the last frame or if it is a control command
while (defined($nextCmd->{targetTime}) && ($nextCmd->{targetTime} < gettimeofday()) && !$actualCmd->{ctrl})
{
shift @{$hash->{helper}->{cmdQueue}};
$actualCmd = @{$hash->{helper}->{cmdQueue}}[0];
$nextCmd = @{$hash->{helper}->{cmdQueue}}[1];
Log3 ($hash, 4, "$hash->{NAME}_CmdQueue_Exec: Drop Frame. Queue Length: ".@{$hash->{helper}->{cmdQueue}});
}
Log3 ($hash, 5, "$hash->{NAME}_CmdQueue_Exec: Dropper Delay: ".($actualCmd->{targetTime} - gettimeofday())) if (defined($actualCmd->{targetTime}));
# set hsv or if a device ctrl command is scheduled: send it and ignore hsv
if ($actualCmd->{ctrl})
{
my $dbgStr = unpack("H*", $actualCmd->{ctrl});
Log3 ($hash, 4, "$hash->{NAME}_CmdQueue_Exec: Send ctrl: $dbgStr; Queue Length: ".@{$hash->{helper}->{cmdQueue}});
IOWrite($hash, $actualCmd->{ctrl});
}
else
{
# Send an HSV Command.
my $repeat = 0;
# If queue length < 2 (ie. 1) we are last command so repeat sending (takes twice as long...)
$repeat = 1 if (@{$hash->{helper}->{cmdQueue}} < 2);
MilightDevice_SetHSV($hash, $actualCmd->{hue}, $actualCmd->{sat}, $actualCmd->{val}, $repeat);
}
$actualCmd->{inProgess} = 1;
my $next = defined($nextCmd->{targetTime})?$nextCmd->{targetTime}:gettimeofday() + ($actualCmd->{delay} / 1000);
Log3 ($hash, 5, "$hash->{NAME}_CmdQueue_Exec: Next Exec: $next");
InternalTimer($next, "MilightDevice_CmdQueue_Exec", $hash, 0);
return undef;
}
#####################################
sub MilightDevice_CmdQueue_Clear(@)
{
my ($hash) = @_;
Log3 ($hash, 4, "$hash->{NAME}_CmdQueue_Clear");
RemoveInternalTimer($hash);
#if ($hash->{IODev}->{STATE} ne "ok" && $hash->{IODev}->{STATE} ne "Initialized") {
# InternalTimer(gettimeofday() + 60, "MilightDevice_CmdQueue_Exec", $hash, 0);
# return undef;
#}
readingsSingleUpdate($hash, "transitionInProgress", 0, 1); # Clear inProgress flag
#foreach my $args (keys %intAt)
#{
# if (($intAt{$args}{ARG} eq $hash) && ($intAt{$args}{FN} eq 'MilightDevice_CmdQueue_Exec'))
# {
# Log3 ($hash, 5, "$hash->{NAME}_CmdQueue_Clear: Remove timer at: ".$intAt{$args}{TRIGGERTIME});
# delete($intAt{$args});
# }
#}
$hash->{helper}->{cmdQueue} = [];
return undef;
}
#####################################
sub MilightDevice_BridgeDevices_Update(@)
{
my ($hash, $attr) = @_;
my @rdlist = ($attr);
if($attr eq 'bulk')
{
@rdlist = ("state","brightness","brightness_on","hue", "saturation", "hsv", "rgb", "discoMode", "discoSpeed")if ($hash->{LEDTYPE} eq 'RGBW');
@rdlist = ("state","brightness","brightness_on","ct")if ($hash->{LEDTYPE} eq 'White');
}
my $sl = 5;
$sl = 1 if ($hash->{LEDTYPE} eq 'White');
for (my $i = 0; $i < 4; $i++)
{
my $devname = $hash->{IODev}->{$sl+$i}->{NAME};
next if (!defined($defs{$devname}));
my $device = $defs{$devname};
$devname = "?" if(!defined($devname));
readingsSingleUpdate($device, "transitionInProgress", 1, 1);
readingsBeginUpdate($device);
foreach my $rdname (@rdlist)
{
if (exists ($device->{READINGS}{$rdname}))
{
readingsBulkUpdate($device, $rdname, $hash->{READINGS}{$rdname}{VAL}, 1);
Log3 ($hash, 4, $rdname.": ".$device->{READINGS}{$rdname}{VAL}." for ".$devname);
}
}
readingsEndUpdate($device, 1);
readingsSingleUpdate($device, "transitionInProgress", 0, 1);
}
return undef;
}
sub MilightDevice_roundfunc($) {
my ($number) = @_;
return sprintf("%.0f", $number);
#return Math::Round::round($number);
}
1;
=pod
=item device
=item summary This module represents a Milight LED Bulb or LED strip controller
=begin html
<a name="MilightDevice"></a>
<h3>MilightDevice</h3>
<ul>
<p>This module represents a Milight LED Bulb or LED strip controller. It is controlled by a <a href="#MilightBridge">MilightBridge</a>.</p>
<p>The Milight system is sold under various brands around the world including "LimitlessLED, EasyBulb, AppLamp"</p>
<p>The API documentation is available here: <a href="http://www.limitlessled.com/dev/">http://www.limitlessled.com/dev/</a></p>
<p>Requires perl module Math::Round</p>
<a name="MilightDevice_define"></a>
<p><b>Define</b></p>
<ul>
<p><code>define &lt;name&gt; MilightDevice &lt;devType(RGB|RGBW|White)&gt; &lt;IODev&gt; &lt;slot&gt;</code></p>
<p>Specifies the Milight device.<br/>
&lt;devType&gt; One of RGB, RGBW, White depending on your device.<br/>
&lt;IODev&gt; The <a href="#MilightBridge">MilightBridge</a> which the device is paired with.<br/>
&lt;slot&gt; The slot on the <a href="#MilightBridge">MilightBridge</a> that the device is paired with or 'A' to group all slots.</p>
</ul>
<a name="MilightDevice_readings"></a>
<p><b>Readings</b></p>
<ul>
<li>
<b>state</b><br/>
[on xxx|off|night]: Current state of the device / night mode (xxx = 0-100%).
</li>
<li>
<b>brightness</b><br/>
[0-100]: Current brightness level in %.
</li>
<li>
<b>brightness_on</b><br/>
[0-100]: The brightness level before the off command was sent. This allows the light to turn back on to the last brightness level.
</li>
<li>
<b>rgb</b><br/>
[FFFFFF]: HEX value for RGB.
</li>
<li>
<b>previousState</b><br/>
[hsv]: hsv value before last change. Can be used with <b>restorePreviousState</b> set command.
</li>
<li>
<b>savedState</b><br/>
[hsv]: hsv value that was saved using <b>saveState</b> set function
</li>
<li>
<b>hue</b><br/>
[0-360]: Current hue value.
</li>
<li>
<b>saturation</b><br/>
[0-100]: Current saturation value.
</li>
<li>
<b>transitionInProgress</b><br/>
[0|1]: Set to 1 if a transition is currently in progress for this device (eg. fade).
</li>
<li>
<b>discoMode</b><br/>
[0|1]: 1 if discoMode is enabled, 0 otherwise.
</li>
<li>
<b>discoSpeed</b><br/>
[0|1]: 1 if discoSpeed is increased, 0 if decreased. Does not mean much for RGBW
</li>
<li>
<b>lastPreset</b><br/>
[0..X]: Last selected preset.
</li>
<li>
<b>ct</b><br/>
[1-10]: Current colour temperature (3000=Warm,6500=Cold) for White devices.
</li>
</ul>
<a name="MilightDevice_set"></a>
<p><b>Set</b></p>
<ul>
<li>
<b>on &lt;ramp_time (seconds)></b>
</li>
<li>
<b>off &lt;ramp_time (seconds)></b>
</li>
<li>
<b>toggle</b>
</li>
<li>
<b>night</b>
</li>
<li>
<b>dim &lt;percent(0..100)&gt; [seconds(0..x)] [flags(l=long path|q=don't clear queue)]</b><br/>
Will be replaced by <i>brightness</i> at some point
</li>
<li>
<b>dimup &lt;percent change(0..100)&gt; [seconds(0..x)]</b><br/>
Special case: If percent change=100, seconds will be adjusted for actual change to go from current brightness.
</li>
<li>
<b>dimdown &lt;percent change(0..100)&gt; [seconds(0..x)]</b><br/>
Special case: If percent change=100, seconds will be adjusted for actual change to go from current brightness.
</li>
<li>
<b>pair</b><br/>
May not work properly. Sometimes it is necessary to use a remote to clear pairing first.
</li>
<li>
<b>unpair</b><br/>
May not work properly. Sometimes it is necessary to use a remote to clear pairing first.
</li>
<li>
<b>restorePreviousState</b><br/>
Set device to previous hsv state as stored in <b>previousState</b> reading.
</li>
<li>
<b>saveState</b><br/>
Save current hsv state to <b>savedState</b> reading.
</li>
<li>
<b>restoreState</b><br/>
Set device to saved hsv state as stored in <b>savedState</b> reading.
</li>
<li>
<b>preset (0..X|+)</b><br/>
Load preset (+ for next preset).
</li>
<li>
<b>hsv &lt;h(0..360)&gt;,&lt;s(0..100)&gt;,&lt;v(0..100)&gt; [seconds(0..x)] [flags(l=long path|q=don't clear queue)]</b><br/>
Set hsv value directly
</li>
<li>
<b>rgb RRGGBB [seconds(0..x)] [flags(l=long path|q=don't clear queue)]</b><br/>
Set rgb value directly or using colorpicker.
</li>
<li>
<b>hue &lt;(0..360)&gt; [seconds(0..x)] [flags(l=long path|q=don't clear queue)]</b><br/>
Set hue value.
</li>
<li>
<b>saturation &lt;s(0..100)&gt; [seconds(0..x)] [flags(q=don't clear queue)]</b><br/>
Set saturation value directly
</li>
<li>
<b>discoModeUp</b><br/>
Next disco Mode setting (for RGB and RGBW).
</li>
<li>
<b>discoModeDown</b><br/>
Previous disco Mode setting (for RGB).
</li>
<li>
<b>discoSpeedUp</b><br/>
Increase speed of disco mode (for RGB and RGBW).
</li>
<li>
<b>discoSpeedDown</b><br/>
Decrease speed of disco mode (for RGB and RGBW).
</li>
<li>
<b>ct &lt;3000-6500&gt;</b><br/>
Colour temperature 3000=Warm White,6500=Cold White (10 steps) (for White devices only).
</li>
<li>
<a href="#setExtensions"> set extensions</a> are supported.
</li>
</ul>
<a name="MilightDevice_get"></a>
<p><b>Get</b></p>
<ul>
<li>
<b>rgb</b>
</li>
<li>
<b>hsv</b>
</li>
</ul>
<a name="MilightDevice_attr"></a>
<p><b>Attributes</b></p>
<ul>
<li>
<b>dimStep</b><br/>
Allows you to modify the default dimStep if required.
</li>
<li>
<b>defaultRampOn</b><br/>
Set the default ramp time if not specified for on command.
</li>
<li>
<b>defaultRampOff</b><br/>
Set the default ramp time if not specified for off command.
</li>
<li>
<b>presets</b><br/>
List of hsv presets separated by spaces (eg 0,0,100 9,0,50).
</li>
<li>
<b>colorCast</b><br/>
Color shift values for red,yellow,green,cyan,blue,magenta (-29..29) for HSV color correction (eg 0,5,10,-5,0,0)
</li>
<li>
<b>gamma</b><br/>
Set gamma correction value for device (eg 0.8)
</li>
<li>
<b>dimOffWhite</b><br/>
Use a different switching logic for White bulbs to better handle packet loss.
</li>
<li>
<b>updateGroupDevices</b><br/>
Update the state of single devices switched with slot 'A'.
</li>
<li>
<b>restoreAtStart</b><br/>
Restore the state of devices at startup. Default 0 for slot 'A', 1 otherwise.
</li>
<li>
<b>defaultBrightness</b><br/>
Set the default brightness if not known. (Default: 36)
</li>
</ul>
</ul>
=end html
=cut
Reference in New Issue View Git Blame Copy Permalink