def test_color_rgb_to_rgbw(self):
"""Test color_rgb_to_rgbw."""
assert (0, 0, 0, 0) == \
color_util.color_rgb_to_rgbw(0, 0, 0)
assert (0, 0, 0, 255) == \
color_util.color_rgb_to_rgbw(255, 255, 255)
assert (255, 0, 0, 0) == \
color_util.color_rgb_to_rgbw(255, 0, 0)
assert (0, 255, 0, 0) == \
color_util.color_rgb_to_rgbw(0, 255, 0)
assert (0, 0, 255, 0) == \
color_util.color_rgb_to_rgbw(0, 0, 255)
assert (255, 127, 0, 0) == \
color_util.color_rgb_to_rgbw(255, 127, 0)
assert (255, 0, 0, 253) == \
color_util.color_rgb_to_rgbw(255, 127, 127)
assert (0, 0, 0, 127) == \
color_util.color_rgb_to_rgbw(127, 127, 127)
def test_color_rgb_to_rgbw(self):
"""Test color_rgb_to_rgbw."""
self.assertEqual((0, 0, 0, 0),
color_util.color_rgb_to_rgbw(0, 0, 0))
self.assertEqual((0, 0, 0, 255),
color_util.color_rgb_to_rgbw(255, 255, 255))
self.assertEqual((255, 0, 0, 0),
color_util.color_rgb_to_rgbw(255, 0, 0))
self.assertEqual((0, 255, 0, 0),
color_util.color_rgb_to_rgbw(0, 255, 0))
self.assertEqual((0, 0, 255, 0),
color_util.color_rgb_to_rgbw(0, 0, 255))
self.assertEqual((255, 127, 0, 0),
color_util.color_rgb_to_rgbw(255, 127, 0))
self.assertEqual((255, 0, 0, 253),
color_util.color_rgb_to_rgbw(255, 127, 127))
self.assertEqual((0, 0, 0, 127),
color_util.color_rgb_to_rgbw(127, 127, 127))
def turn_on(self, **kwargs):
"""Turn the device on."""
rgbw = None
if ATTR_COLOR_TEMP in kwargs:
# Color temperature. With the AEOTEC ZW098 bulb, only two color
# temperatures are supported. The warm and cold channel values
# indicate brightness for warm/cold color temperature.
if self._zw098:
if kwargs[ATTR_COLOR_TEMP] > TEMP_MID_HASS:
self._ct = TEMP_WARM_HASS
rgbw = '#000000ff00'
else:
self._ct = TEMP_COLD_HASS
rgbw = '#00000000ff'
elif ATTR_RGB_COLOR in kwargs:
self._rgb = kwargs[ATTR_RGB_COLOR]
if (not self._zw098 and (
self._color_channels & COLOR_CHANNEL_WARM_WHITE or
self._color_channels & COLOR_CHANNEL_COLD_WHITE)):
rgbw = '#'
for colorval in color_rgb_to_rgbw(*self._rgb):
rgbw += format(colorval, '02x')
rgbw += '00'
else:
rgbw = '#'
for colorval in self._rgb:
rgbw += format(colorval, '02x')
rgbw += '0000'
if rgbw and self.values.color:
self.values.color.data = rgbw
super().turn_on(**kwargs)
def dmx_values(self):
# Select which values to send over DMX
if self._type == CONF_LIGHT_TYPE_RGB:
# Scale the RGB colour value to the selected brightness
return scale_rgb_to_brightness(self._rgb, self._brightness)
elif self._type == CONF_LIGHT_TYPE_RGBW:
rgbw = scale_rgb_to_brightness(self._rgb, self._brightness)
rgbw.append(round(self._white_value * (self._brightness / 255)))
return rgbw
elif self._type == CONF_LIGHT_TYPE_RGBW_AUTO:
# Split the white component out from the scaled RGB values
scaled_rgb = scale_rgb_to_brightness(self._rgb, self._brightness)
return color_rgb_to_rgbw(*scaled_rgb)
elif self._type == CONF_LIGHT_TYPE_DRGB:
drgb = [self._brightness]
drgb.extend(self._rgb)
return drgb
elif self._type == CONF_LIGHT_TYPE_RGBWD:
rgbwd = list()
rgbwd.extend(self._rgb)
rgbwd.append(self._white_value)
rgbwd.append(self._brightness)
return rgbwd
else:
return self._brightness
async def async_turn_on(self, **kwargs: Any) -> None:
"""Turn on the light."""
data = {ATTR_ON: True, ATTR_SEGMENT_ID: self._segment}
if ATTR_COLOR_TEMP in kwargs:
mireds = color_util.color_temperature_kelvin_to_mired(
kwargs[ATTR_COLOR_TEMP])
data[ATTR_COLOR_PRIMARY] = tuple(
map(int, color_util.color_temperature_to_rgb(mireds)))
if ATTR_HS_COLOR in kwargs:
hue, sat = kwargs[ATTR_HS_COLOR]
data[ATTR_COLOR_PRIMARY] = color_util.color_hsv_to_RGB(
hue, sat, 100)
if ATTR_TRANSITION in kwargs:
data[ATTR_TRANSITION] = kwargs[ATTR_TRANSITION]
if ATTR_BRIGHTNESS in kwargs:
data[ATTR_BRIGHTNESS] = kwargs[ATTR_BRIGHTNESS]
if ATTR_EFFECT in kwargs:
data[ATTR_EFFECT] = kwargs[ATTR_EFFECT]
# Support for RGBW strips
if self._rgbw and any(x in (ATTR_COLOR_TEMP, ATTR_HS_COLOR)
for x in kwargs):
data[ATTR_COLOR_PRIMARY] = color_util.color_rgb_to_rgbw(
*data[ATTR_COLOR_PRIMARY])
try:
await self.wled.light(**data)
self._state = True
if ATTR_BRIGHTNESS in kwargs:
self._brightness = kwargs[ATTR_BRIGHTNESS]
if ATTR_EFFECT in kwargs:
self._effect = kwargs[ATTR_EFFECT]
if ATTR_HS_COLOR in kwargs:
self._color = kwargs[ATTR_HS_COLOR]
if ATTR_COLOR_TEMP in kwargs:
self._color = color_util.color_temperature_to_hs(mireds)
except WLEDError:
_LOGGER.error("An error occurred while turning on WLED light.")
self._available = False
self.async_schedule_update_ha_state()
def test_color_rgb_to_rgbw():
"""Test color_rgb_to_rgbw."""
assert color_util.color_rgb_to_rgbw(0, 0, 0) == (0, 0, 0, 0)
assert color_util.color_rgb_to_rgbw(255, 255, 255) == (0, 0, 0, 255)
assert color_util.color_rgb_to_rgbw(255, 0, 0) == (255, 0, 0, 0)
assert color_util.color_rgb_to_rgbw(0, 255, 0) == (0, 255, 0, 0)
assert color_util.color_rgb_to_rgbw(0, 0, 255) == (0, 0, 255, 0)
assert color_util.color_rgb_to_rgbw(255, 127, 0) == (255, 127, 0, 0)
assert color_util.color_rgb_to_rgbw(255, 127, 127) == (255, 0, 0, 253)
assert color_util.color_rgb_to_rgbw(127, 127, 127) == (0, 0, 0, 127)
def __getRGBWValueFromRGBValue(self, rgbColorValue):
rgbwColorValue = [0, 0, 0, 0]
if (self.__type == LightType.RGBW):
rgbwColorValue = color_rgb_to_rgbw(
rgbColorValue[0],
rgbColorValue[1],
rgbColorValue[2]
)
else:
rgbwColorValue[0:3] = rgbColorValue
## Convert all elements from float to integer
rgbwColorValue = list(map(lambda x: int(x), rgbwColorValue))
return rgbwColorValue
def turn_on(self, **kwargs):
if ATTR_TRANSITION in kwargs:
self._transition = int(kwargs.get(ATTR_TRANSITION) * 1000)
if ATTR_RGB_COLOR in kwargs or ATTR_HS_COLOR in kwargs:
if ATTR_RGB_COLOR in kwargs:
self._rgb_color = kwargs.get(ATTR_RGB_COLOR)
elif ATTR_HS_COLOR in kwargs:
self._rgb_color = color_util.color_hs_to_RGB(
*kwargs.get(ATTR_HS_COLOR))
rgbw = color_util.color_rgb_to_rgbw(*self._rgb_color)
self.xpwm_rgbw_r.set_level(scaleto100(rgbw[0]), self._transition)
self.xpwm_rgbw_g.set_level(scaleto100(rgbw[1]), self._transition)
self.xpwm_rgbw_b.set_level(scaleto100(rgbw[2]), self._transition)
self.xpwm_rgbw_w.set_level(scaleto100(rgbw[3]), self._transition)
elif ATTR_WHITE_VALUE in kwargs:
self._white_value = kwargs.get(ATTR_WHITE_VALUE)
self.xpwm_rgbw_w.set_level(scaleto100(self._white_value),
self._transition)
elif ATTR_BRIGHTNESS in kwargs:
self._brightness = kwargs.get(ATTR_BRIGHTNESS)
if self._state:
self.xpwm_rgbw_r.set_level(
scaleto100(self.xpwm_rgbw_r.level * self._brightness /
255),
self._transition,
)
self.xpwm_rgbw_g.set_level(
scaleto100(self.xpwm_rgbw_g.level * self._brightness /
255),
self._transition,
)
self.xpwm_rgbw_b.set_level(
scaleto100(self.xpwm_rgbw_b.level * self._brightness /
255),
self._transition,
)
self.xpwm_rgbw_w.set_level(
scaleto100(self.xpwm_rgbw_w.level * self._brightness /
255),
self._transition,
)
else:
self.xpwm_rgbw_w.set_level(scaleto100(self._brightness),
self._transition)
else:
self.xpwm_rgbw_w.on(self._transition)
def turn_on(self, **kwargs):
"""Turn the device on."""
rgbw = None
if ATTR_COLOR_TEMP in kwargs:
# Color temperature. With the AEOTEC ZW098 bulb, only two color
# temperatures are supported. The warm and cold channel values
# indicate brightness for warm/cold color temperature.
if self._zw098:
if kwargs[ATTR_COLOR_TEMP] > TEMP_MID_HASS:
self._ct = TEMP_WARM_HASS
rgbw = b'#000000FF00'
else:
self._ct = TEMP_COLD_HASS
rgbw = b'#00000000FF'
elif ATTR_RGB_COLOR in kwargs:
self._rgb = kwargs[ATTR_RGB_COLOR]
if (not self._zw098 and (
self._color_channels & COLOR_CHANNEL_WARM_WHITE or
self._color_channels & COLOR_CHANNEL_COLD_WHITE)):
rgbw = b'#'
for colorval in color_rgb_to_rgbw(*self._rgb):
rgbw += format(colorval, '02x').encode('utf-8')
rgbw += b'00'
else:
rgbw = b'#'
for colorval in self._rgb:
rgbw += format(colorval, '02x').encode('utf-8')
rgbw += b'0000'
if rgbw is None:
_LOGGER.warning("rgbw string was not generated for turn_on")
else:
self._value_color.node.set_rgbw(self._value_color.value_id, rgbw)
super().turn_on(**kwargs)
def turn_on(self, **kwargs):
"""Turn the device on."""
rgbw = None
if ATTR_COLOR_TEMP in kwargs:
# Color temperature. With the AEOTEC ZW098 bulb, only two color
# temperatures are supported. The warm and cold channel values
# indicate brightness for warm/cold color temperature.
if self._zw098:
if kwargs[ATTR_COLOR_TEMP] > TEMP_MID_HASS:
self._ct = TEMP_WARM_HASS
rgbw = b'#000000FF00'
else:
self._ct = TEMP_COLD_HASS
rgbw = b'#00000000FF'
elif ATTR_RGB_COLOR in kwargs:
self._rgb = kwargs[ATTR_RGB_COLOR]
if (not self._zw098 and (
self._color_channels & COLOR_CHANNEL_WARM_WHITE or
self._color_channels & COLOR_CHANNEL_COLD_WHITE)):
rgbw = b'#'
for colorval in color_rgb_to_rgbw(*self._rgb):
rgbw += format(colorval, '02x').encode('utf-8')
rgbw += b'00'
else:
rgbw = b'#'
for colorval in self._rgb:
rgbw += format(colorval, '02x').encode('utf-8')
rgbw += b'0000'
if rgbw is None:
_LOGGER.warning("rgbw string was not generated for turn_on")
else:
self._value_color.node.set_rgbw(self._value_color.value_id, rgbw)
super().turn_on(**kwargs)
params[ATTR_HS_COLOR] = color_util.color_xy_to_hs(*xy_color)
elif (rgbw_color := params.pop(ATTR_RGBW_COLOR, None)) is not None:
rgb_color = color_util.color_rgbw_to_rgb(*rgbw_color)
params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
elif (rgbww_color := params.pop(ATTR_RGBWW_COLOR,
None)) is not None:
rgb_color = color_util.color_rgbww_to_rgb(
*rgbww_color, light.min_mireds, light.max_mireds)
params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
elif ATTR_HS_COLOR in params and ColorMode.HS not in supported_color_modes:
hs_color = params.pop(ATTR_HS_COLOR)
if ColorMode.RGB in supported_color_modes:
params[ATTR_RGB_COLOR] = color_util.color_hs_to_RGB(*hs_color)
elif ColorMode.RGBW in supported_color_modes:
rgb_color = color_util.color_hs_to_RGB(*hs_color)
params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(
*rgb_color)
elif ColorMode.RGBWW in supported_color_modes:
rgb_color = color_util.color_hs_to_RGB(*hs_color)
params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
*rgb_color, light.min_mireds, light.max_mireds)
elif ColorMode.XY in supported_color_modes:
params[ATTR_XY_COLOR] = color_util.color_hs_to_xy(*hs_color)
elif ATTR_RGB_COLOR in params and ColorMode.RGB not in supported_color_modes:
rgb_color = params.pop(ATTR_RGB_COLOR)
if ColorMode.RGBW in supported_color_modes:
params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(
*rgb_color)
elif ColorMode.RGBWW in supported_color_modes:
params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
*rgb_color, light.min_mireds, light.max_mireds)
elif ColorMode.HS in supported_color_modes:
def dmx_values(self):
# Select which values to send over DMX
if self._type == CONF_LIGHT_TYPE_RGB:
# Scale the RGB colour value to the selected brightness
return scale_rgb_to_brightness(self._rgb, self._brightness)
elif self._type == CONF_LIGHT_TYPE_RGBA:
# Split the white component out from the scaled RGB values
rgba = scale_rgb_to_brightness(self._rgb, self._brightness)
amber = rgba[0]
if (amber > rgba[1] * 2):
amber = rgba[1] * 2
rgba[0] = rgba[0] - amber
rgba[1] = round(rgba[1] - amber/2)
rgba.append(amber)
return rgba
elif self._type == CONF_LIGHT_TYPE_RGBAW:
# Split the white component out from the scaled RGB values
values = scale_rgb_to_brightness(self._rgb, self._brightness)
amber = values[0]
if (amber > values[1] * 2):
amber = values[1] * 2
values[0] = values[0] - amber
values[1] = round(values[1] - amber/2)
values.append(amber)
values.append(round(self._white_value * (self._brightness / 255)))
return values
elif self._type == CONF_LIGHT_TYPE_RGBW:
rgbw = scale_rgb_to_brightness(self._rgb, self._brightness)
rgbw.append(round(self._white_value * (self._brightness / 255)))
return rgbw
elif self._type == CONF_LIGHT_TYPE_RGBW_AUTO:
# Split the white component out from the scaled RGB values
scaled_rgb = scale_rgb_to_brightness(self._rgb, self._brightness)
return color_rgb_to_rgbw(*scaled_rgb)
elif self._type == CONF_LIGHT_TYPE_DRGB:
drgb = [self._brightness]
drgb.extend(self._rgb if self._brightness > 0 else [0, 0, 0])
_LOGGER.debug("drgb: " + ', '.join([str(x) for x in drgb]));
return drgb
elif self._type == CONF_LIGHT_TYPE_DRGBW:
drgbw = [self._brightness]
drgbw.extend(self._rgb if self._brightness > 0 else [0, 0, 0])
drgbw.append(self._white_value if self.brightness > 0 else 0)
_LOGGER.debug("drgbw: " + ', '.join([str(x) for x in drgbw]));
return drgbw
elif self._type == CONF_LIGHT_TYPE_RGBWD:
rgbwd = list()
rgbwd.extend(self._rgb if self._brightness > 0 else [0, 0, 0])
rgbwd.append(self._white_value if self._brightness > 0 else 0)
rgbwd.append(self._brightness)
_LOGGER.debug("rgbwd: " + ', '.join([str(x) for x in rgbwd]));
return rgbwd
elif self._type == CONF_LIGHT_TYPE_SWITCH:
if self.is_on:
return 255
else:
return 0
elif self._type == CONF_LIGHT_TYPE_CUSTOM_WHITE:
# d = dimmer
# c = cool (scaled for brightness)
# C = cool (not scaled)
# h = hot (scaled for brightness)
# H = hot (not scaled)
# t = temperature (0 = hot, 255 = cold)
# T = temperature (255 = hot, 0 = cold)
ww_fraction = (self._color_temp - self.min_mireds) / (
self.max_mireds - self.min_mireds)
cw_fraction = 1 - ww_fraction
max_fraction = max(ww_fraction, cw_fraction)
switcher = {
'd': self._brightness,
't': 255 - (ww_fraction * 255),
'T': ww_fraction * 255,
'h': self.is_on * self._brightness * (ww_fraction / max_fraction),
'c': self.is_on * self._brightness * (cw_fraction / max_fraction),
}
values = list()
for channel in self._channel_setup:
values.append(int(round(switcher.get(channel, 0))))
return values
else:
return self._brightness
