Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert flux_led to 0.89 (#25653) 

* Revert Black

* Revert "Introduce support for color temperature (#25503)"

This reverts commit e1d884a484.

* Revert "Fix flux_led only-white controllers (#22210)"

This reverts commit 48138189b3.

* Revert "Fix MagicHome LEDs with flux_led component (#20733)"

This reverts commit 1444a684e0.

* Re-Black

* Use mode detection for scanned bulbs
pull/25510/head
Anders Melchiorsen 2019-08-02 17:00:22 +02:00 committed by Pascal Vizeli
parent a2f9a5287d
commit 2f7c57b257
1 changed files with 55 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
homeassistant/components/flux_led/light.py
View File

@ -2,8 +2,6 @@
import logging import logging
import socket import socket
import random import random
from asyncio import sleep
from functools import partial
import voluptuous as vol import voluptuous as vol
@ -13,14 +11,12 @@ from homeassistant.components.light import (
ATTR_HS_COLOR, ATTR_HS_COLOR,
ATTR_EFFECT, ATTR_EFFECT,
ATTR_WHITE_VALUE, ATTR_WHITE_VALUE,
ATTR_COLOR_TEMP,
EFFECT_COLORLOOP, EFFECT_COLORLOOP,
EFFECT_RANDOM, EFFECT_RANDOM,
SUPPORT_BRIGHTNESS, SUPPORT_BRIGHTNESS,
SUPPORT_EFFECT, SUPPORT_EFFECT,
SUPPORT_COLOR, SUPPORT_COLOR,
SUPPORT_WHITE_VALUE, SUPPORT_WHITE_VALUE,
SUPPORT_COLOR_TEMP,
Light, Light,
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
) )
@ -38,9 +34,7 @@ ATTR_MODE = "mode"
DOMAIN = "flux_led" DOMAIN = "flux_led"
SUPPORT_FLUX_LED = ( SUPPORT_FLUX_LED = SUPPORT_BRIGHTNESS | SUPPORT_EFFECT | SUPPORT_COLOR
SUPPORT_BRIGHTNESS | SUPPORT_EFFECT | SUPPORT_COLOR | SUPPORT_COLOR_TEMP
)
MODE_RGB = "rgb" MODE_RGB = "rgb"
MODE_RGBW = "rgbw" MODE_RGBW = "rgbw"
@ -49,11 +43,6 @@ MODE_RGBW = "rgbw"
# RGB value is ignored when this mode is specified. # RGB value is ignored when this mode is specified.
MODE_WHITE = "w" MODE_WHITE = "w"
# Constant color temp values for 2 flux_led special modes
# Warm-white and Cool-white. Details on #23704
COLOR_TEMP_WARM_WHITE = 333
COLOR_TEMP_COOL_WHITE = 250
# List of supported effects which aren't already declared in LIGHT # List of supported effects which aren't already declared in LIGHT
EFFECT_RED_FADE = "red_fade" EFFECT_RED_FADE = "red_fade"
EFFECT_GREEN_FADE = "green_fade" EFFECT_GREEN_FADE = "green_fade"
@ -196,8 +185,6 @@ class FluxLight(Light):
self._custom_effect = device[CONF_CUSTOM_EFFECT] self._custom_effect = device[CONF_CUSTOM_EFFECT]
self._bulb = None self._bulb = None
self._error_reported = False self._error_reported = False
self._color = (0, 0, 100)
self._white_value = 0
def _connect(self): def _connect(self):
"""Connect to Flux light.""" """Connect to Flux light."""
@ -238,14 +225,14 @@ class FluxLight(Light):
def brightness(self): def brightness(self):
"""Return the brightness of this light between 0..255.""" """Return the brightness of this light between 0..255."""
if self._mode == MODE_WHITE: if self._mode == MODE_WHITE:
return self._white_value return self.white_value
return int(self._color[2] / 100 * 255) return self._bulb.brightness
@property @property
def hs_color(self): def hs_color(self):
"""Return the color property.""" """Return the color property."""
return self._color[0:2] return color_util.color_RGB_to_hs(*self._bulb.getRgb())
@property @property
def supported_features(self): def supported_features(self):
@ -261,7 +248,7 @@ class FluxLight(Light):
@property @property
def white_value(self): def white_value(self):
"""Return the white value of this light between 0..255.""" """Return the white value of this light between 0..255."""
return self._white_value return self._bulb.getRgbw()[3]
@property @property
def effect_list(self): def effect_list(self):
@ -282,85 +269,75 @@ class FluxLight(Light):
for effect, code in EFFECT_MAP.items(): for effect, code in EFFECT_MAP.items():
if current_mode == code: if current_mode == code:
return effect return effect
return None return None
async def async_turn_on(self, **kwargs): def turn_on(self, **kwargs):
"""Turn the specified or all lights on and wait for state."""
await self.hass.async_add_executor_job(partial(self._turn_on, **kwargs))
# The bulb needs a bit to tell its new values,
# so we wait 1 second before updating
await sleep(1)
def _turn_on(self, **kwargs):
"""Turn the specified or all lights on.""" """Turn the specified or all lights on."""
self._bulb.turnOn() if not self.is_on:
self._bulb.turnOn()
hs_color = kwargs.get(ATTR_HS_COLOR) hs_color = kwargs.get(ATTR_HS_COLOR)
if hs_color:
rgb = color_util.color_hs_to_RGB(*hs_color)
else:
rgb = None
brightness = kwargs.get(ATTR_BRIGHTNESS) brightness = kwargs.get(ATTR_BRIGHTNESS)
effect = kwargs.get(ATTR_EFFECT) effect = kwargs.get(ATTR_EFFECT)
white = kwargs.get(ATTR_WHITE_VALUE) white = kwargs.get(ATTR_WHITE_VALUE)
color_temp = kwargs.get(ATTR_COLOR_TEMP)
if all( # Show warning if effect set with rgb, brightness, or white level
item is None for item in [hs_color, brightness, effect, white, color_temp] if effect and (brightness or white or rgb):
): _LOGGER.warning(
"RGB, brightness and white level are ignored when"
" an effect is specified for a flux bulb"
)
# Random color effect
if effect == EFFECT_RANDOM:
self._bulb.setRgb(
random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)
)
return return
# handle W only mode (use brightness instead of white value) if effect == EFFECT_CUSTOM:
if self._mode == MODE_WHITE: if self._custom_effect:
if brightness is not None: self._bulb.setCustomPattern(
self._bulb.setWarmWhite255(brightness) self._custom_effect[CONF_COLORS],
return self._custom_effect[CONF_SPEED_PCT],
self._custom_effect[CONF_TRANSITION],
# handle effects
if effect is not None:
# Random color effect
if effect == EFFECT_RANDOM:
self._bulb.setRgb(
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255),
) )
elif effect == EFFECT_CUSTOM:
if self._custom_effect:
self._bulb.setCustomPattern(
self._custom_effect[CONF_COLORS],
self._custom_effect[CONF_SPEED_PCT],
self._custom_effect[CONF_TRANSITION],
)
# Effect selection
elif effect in EFFECT_MAP:
self._bulb.setPresetPattern(EFFECT_MAP[effect], 50)
return return
# handle special modes # Effect selection
if color_temp is not None: if effect in EFFECT_MAP:
if brightness is None: self._bulb.setPresetPattern(EFFECT_MAP[effect], 50)
brightness = self.brightness
if color_temp == COLOR_TEMP_WARM_WHITE:
self._bulb.setRgbw(w=brightness)
elif color_temp == COLOR_TEMP_COOL_WHITE:
self._bulb.setRgbw(w2=brightness)
else:
self._bulb.setRgbw(*color_util.color_temperature_to_rgb(color_temp))
return return
# Preserve current brightness on color/white level change # Preserve current brightness on color/white level change
if hs_color is not None: if brightness is None:
if brightness is None: brightness = self.brightness
brightness = self.brightness
color = (hs_color[0], hs_color[1], brightness / 255 * 100) # Preserve color on brightness/white level change
elif brightness is not None: if rgb is None:
color = (self._color[0], self._color[1], brightness / 255 * 100) rgb = self._bulb.getRgb()
if white is None and self._mode == MODE_RGBW:
white = self.white_value
# handle W only mode (use brightness instead of white value)
if self._mode == MODE_WHITE:
self._bulb.setRgbw(0, 0, 0, w=brightness)
# handle RGBW mode # handle RGBW mode
if self._mode == MODE_RGBW: elif self._mode == MODE_RGBW:
if white is None: self._bulb.setRgbw(*tuple(rgb), w=white, brightness=brightness)
self._bulb.setRgbw(*color_util.color_hsv_to_RGB(*color))
else:
self._bulb.setRgbw(w=white)
# handle RGB mode # handle RGB mode
else: else:
self._bulb.setRgb(*color_util.color_hsv_to_RGB(*color)) self._bulb.setRgb(*tuple(rgb), brightness=brightness)
def turn_off(self, **kwargs): def turn_off(self, **kwargs):
"""Turn the specified or all lights off.""" """Turn the specified or all lights off."""
@ -380,10 +357,5 @@ class FluxLight(Light):
) )
self._error_reported = True self._error_reported = True
return return
self._bulb.update_state(retry=2) self._bulb.update_state(retry=2)
if self._mode != MODE_WHITE and self._bulb.getRgb() != (0, 0, 0):
color = self._bulb.getRgbw()
self._color = color_util.color_RGB_to_hsv(*color[0:3])
self._white_value = color[3]
elif self._mode == MODE_WHITE:
self._white_value = self._bulb.getRgbw()[3]