def calc_rgb(self): if self.is_sleep(): _LOGGER.debug(self._name + " in Sleep mode") return color_temperature_to_rgb( self._attributes['sleep_colortemp']) else: return color_temperature_to_rgb(self._cl.data['colortemp'])
def flux_update(self, now=None): """Update all the lights using flux.""" if now is None: now = dt_now() sunset = next_setting(self.hass, SUN).replace(day=now.day, month=now.month, year=now.year) start_time = self.find_start_time(now) stop_time = now.replace(hour=self._stop_time.hour, minute=self._stop_time.minute, second=0) if start_time < now < sunset: # Daytime time_state = 'day' temp_range = abs(self._start_colortemp - self._sunset_colortemp) day_length = int(sunset.timestamp() - start_time.timestamp()) seconds_from_start = int(now.timestamp() - start_time.timestamp()) percentage_complete = seconds_from_start / day_length temp_offset = temp_range * percentage_complete if self._start_colortemp > self._sunset_colortemp: temp = self._start_colortemp - temp_offset else: temp = self._start_colortemp + temp_offset else: # Nightime time_state = 'night' if now < stop_time and now > start_time: now_time = now else: now_time = stop_time temp_range = abs(self._sunset_colortemp - self._stop_colortemp) night_length = int(stop_time.timestamp() - sunset.timestamp()) seconds_from_sunset = int(now_time.timestamp() - sunset.timestamp()) percentage_complete = seconds_from_sunset / night_length temp_offset = temp_range * percentage_complete if self._sunset_colortemp > self._stop_colortemp: temp = self._sunset_colortemp - temp_offset else: temp = self._sunset_colortemp + temp_offset x_val, y_val, b_val = color_RGB_to_xy(*color_temperature_to_rgb(temp)) brightness = self._brightness if self._brightness else b_val if self._mode == MODE_XY: set_lights_xy(self.hass, self._lights, x_val, y_val, brightness) _LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%%" " of %s cycle complete at %s", x_val, y_val, brightness, round( percentage_complete * 100), time_state, as_local(now)) else: # Convert to mired and clamp to allowed values mired = color_temperature_kelvin_to_mired(temp) mired = max(HASS_COLOR_MIN, min(mired, HASS_COLOR_MAX)) set_lights_temp(self.hass, self._lights, mired, brightness) _LOGGER.info("Lights updated to mired:%s brightness:%s, %s%%" " of %s cycle complete at %s", mired, brightness, round(percentage_complete * 100), time_state, as_local(now))
def _status_cb(self, _): _LOGGER.debug("Got notification from the lamp") from yeelightbt import LampMode if not self._dev.color: _LOGGER.error("no color available -> device not connected") return # notification not yet there.. self._brightness = 255 * (int(self._dev.brightness) / 100) self._available = self._dev.available self._state = self._dev.is_on if self._dev.mode == LampMode.White: self._ct = int(kelvin_to_mired(self._dev.temperature)) self._color_temp = self._ct # when in white mode, rgb is not set so we calculate it ourselves self._rgb = color_temperature_to_rgb(self._dev.temperature) else: if self._dev.temperature > 0: self._ct = int(kelvin_to_mired(self._dev.temperature)) else: self._ct = int(kelvin_to_mired(2400)) self._rgb = self._dev.color _LOGGER.debug("available: %s state: %s rgb: %s ct: %s", self._available, self._state, self._rgb, self._ct) self._is_updating = False self.schedule_update_ha_state()
def update_sensor(self): if self._cl.data is not None: self._state = self._cl.data['percent'] self._hs_color = self._cl.data['hs_color'] self._attributes = self._cl.data min_brightness = 30 max_brightness = 100 brightness = int(((max_brightness - min_brightness) * ((100 + self._cl.data['percent']) / 100)) + (min_brightness / 100) * 254) ct = color_temperature_kelvin_to_mired(self._cl.data['colortemp']) rgb = color_temperature_to_rgb(self._cl.data['colortemp']) _LOGGER.debug("RGB values: " + str(rgb)) xy = color_RGB_to_xy(rgb[0], rgb[1], rgb[2]) url = "http://" + hue_gateway + "/api/" + key + "/scenes/" r = requests.get(url).json() scenes = [] for val in r: name = r[val]['name'] if re.match(r"Circadian", name): scenes.append(val) for val in scenes: update_scene_lights(val, brightness, xy[0], xy[1], ct)
def set_state(self, **kwargs): """Turn the light on.""" self._set_ramp(**kwargs) if ATTR_BRIGHTNESS in kwargs: # TODO: is_dimmable test fails for GROUP load types # and self._vantage_device.is_dimmable: brightness = kwargs[ATTR_BRIGHTNESS] self._set_level(brightness) if ATTR_RGB_COLOR in kwargs: _LOGGER.debug("%s set via ATTR_RGB_COLOR", self) self._vantage_device.rgb = kwargs[ATTR_RGB_COLOR] elif ATTR_HS_COLOR in kwargs: _LOGGER.debug("%s set via ATTR_HS_COLOR", self) hs_color = kwargs[ATTR_HS_COLOR] rgb = color_hs_to_RGB(*hs_color) self._vantage_device.rgb = [*rgb] elif ATTR_COLOR_TEMP in kwargs: _LOGGER.debug("%s set via ATTR_COLOR_TEMP - %s", self, kwargs[ATTR_COLOR_TEMP]) # Color temp in HA is in mireds: # https://en.wikipedia.org/wiki/Mired # M = 1000000/KELVIN_TEMP kelvin = int( color_temperature_mired_to_kelvin(kwargs[ATTR_COLOR_TEMP])) _LOGGER.debug("%s vantage color temp kelvin = %s", self, kelvin) if self._vantage_device._dmx_color: # do conversion rgb = color_temperature_to_rgb(kelvin) self._vantage_device.rgb = [*rgb] elif self._vantage_device._load_type == "DW": rgb = self.color_temperature_to_dw_27k41k(kelvin) self._vantage_device.rgb = [*rgb] self._vantage_device.color_temp = kelvin self.schedule_update_ha_state()
def get_settings( self, is_sleep ) -> Dict[str, Union[float, Tuple[float, float], Tuple[float, float, float]]]: """Get all light settings. Calculating all values takes <0.5ms. """ percent = self.calc_percent() brightness_pct = self.calc_brightness_pct(percent, is_sleep) color_temp_kelvin = self.calc_color_temp_kelvin(percent, is_sleep) color_temp_mired: float = color_temperature_kelvin_to_mired( color_temp_kelvin) rgb_color: Tuple[float, float, float] = color_temperature_to_rgb(color_temp_kelvin) xy_color: Tuple[float, float] = color_RGB_to_xy(*rgb_color) hs_color: Tuple[float, float] = color_xy_to_hs(*xy_color) return { "brightness_pct": brightness_pct, "color_temp_kelvin": color_temp_kelvin, "color_temp_mired": color_temp_mired, "rgb_color": rgb_color, "xy_color": xy_color, "hs_color": hs_color, }
def flux_update(self, now=None): """Update all the lights using flux.""" if now is None: now = dt_now() sunset = next_setting(self.hass, SUN).replace(day=now.day, month=now.month, year=now.year) start_time = self.find_start_time(now) stop_time = now.replace(hour=self._stop_time.hour, minute=self._stop_time.minute, second=0) if start_time < now < sunset: # Daytime time_state = 'day' temp_range = abs(self._start_colortemp - self._sunset_colortemp) day_length = int(sunset.timestamp() - start_time.timestamp()) seconds_from_start = int(now.timestamp() - start_time.timestamp()) percentage_complete = seconds_from_start / day_length temp_offset = temp_range * percentage_complete if self._start_colortemp > self._sunset_colortemp: temp = self._start_colortemp - temp_offset else: temp = self._start_colortemp + temp_offset else: # Nightime time_state = 'night' if now < stop_time and now > start_time: now_time = now else: now_time = stop_time temp_range = abs(self._sunset_colortemp - self._stop_colortemp) night_length = int(stop_time.timestamp() - sunset.timestamp()) seconds_from_sunset = int(now_time.timestamp() - sunset.timestamp()) percentage_complete = seconds_from_sunset / night_length temp_offset = temp_range * percentage_complete if self._sunset_colortemp > self._stop_colortemp: temp = self._sunset_colortemp - temp_offset else: temp = self._sunset_colortemp + temp_offset x_val, y_val, b_val = color_RGB_to_xy(*color_temperature_to_rgb(temp)) brightness = self._brightness if self._brightness else b_val if self._disable_brightness_adjust: brightness = None if self._mode == MODE_XY: set_lights_xy(self.hass, self._lights, x_val, y_val, brightness) _LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%%" " of %s cycle complete at %s", x_val, y_val, brightness, round( percentage_complete * 100), time_state, now) else: # Convert to mired and clamp to allowed values mired = color_temperature_kelvin_to_mired(temp) mired = max(HASS_COLOR_MIN, min(mired, HASS_COLOR_MAX)) set_lights_temp(self.hass, self._lights, mired, brightness) _LOGGER.info("Lights updated to mired:%s brightness:%s, %s%%" " of %s cycle complete at %s", mired, brightness, round(percentage_complete * 100), time_state, now)
def test_should_return_pure_white_at_6600(self): """ Function should return red=255, blue=255, green=255 when given 6600K. 6600K is considered "pure white" light. This is just a rough estimate because the formula itself is a "best guess" approach. """ rgb = color_util.color_temperature_to_rgb(6600) self.assertEqual((255, 255, 255), rgb)
def test_should_return_pure_white_at_6600(): """ Function should return red=255, blue=255, green=255 when given 6600K. 6600K is considered "pure white" light. This is just a rough estimate because the formula itself is a "best guess" approach. """ rgb = color_util.color_temperature_to_rgb(6600) assert (255, 255, 255) == rgb
async def _update_attrs(self): """Update Adaptive Values.""" # Setting all values because this method takes <0.5ms to execute. self._percent = self._calc_percent() self._brightness = self._calc_brightness() self._color_temp_kelvin = self._calc_color_temp_kelvin() self._color_temp_mired = color_temperature_kelvin_to_mired( self._color_temp_kelvin) self._rgb_color = color_temperature_to_rgb(self._color_temp_kelvin) self._xy_color = color_RGB_to_xy(*self._rgb_color) self._hs_color = color_xy_to_hs(*self._xy_color) self.async_write_ha_state() _LOGGER.debug("'_update_attrs' called for %s", self._name)
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()
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: # WLED uses 100ms per unit, so 10 = 1 second. data[ATTR_TRANSITION] = round(kwargs[ATTR_TRANSITION] * 10) 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, adds white value if self._rgbw and any( x in (ATTR_COLOR_TEMP, ATTR_HS_COLOR, ATTR_WHITE_VALUE) for x in kwargs): # WLED cannot just accept a white value, it needs the color. # We use the last know color in case just the white value changes. if all(x not in (ATTR_COLOR_TEMP, ATTR_HS_COLOR) for x in kwargs): hue, sat = self.hs_color data[ATTR_COLOR_PRIMARY] = color_util.color_hsv_to_RGB( hue, sat, 100) # On a RGBW strip, when the color is pure white, disable the RGB LEDs in # WLED by setting RGB to 0,0,0 if data[ATTR_COLOR_PRIMARY] == (255, 255, 255): data[ATTR_COLOR_PRIMARY] = (0, 0, 0) # Add requested or last known white value if ATTR_WHITE_VALUE in kwargs: data[ATTR_COLOR_PRIMARY] += (kwargs[ATTR_WHITE_VALUE], ) else: data[ATTR_COLOR_PRIMARY] += (self.white_value, ) await self.coordinator.wled.light(**data)
async def async_turn_on(self, **kwargs: Any) -> None: options = [] if kwargs.get(ATTR_BRIGHTNESS) is not None: _LOGGER.debug("Setting brightness") brightness = round((kwargs.get(ATTR_BRIGHTNESS) / 255) * 100) options.append( create_pid_pair(PropertyIDs.BRIGHTNESS, str(brightness))) _LOGGER.debug("Setting brightness to %s" % brightness) _LOGGER.debug("Options: %s" % options) self._bulb.brightness = brightness if kwargs.get(ATTR_COLOR_TEMP) is not None: _LOGGER.debug("Setting color temp") color_temp = color_util.color_temperature_mired_to_kelvin( kwargs.get(ATTR_COLOR_TEMP)) options.append( create_pid_pair(PropertyIDs.COLOR_TEMP, str(color_temp))) self._bulb.color_temp = color_temp self._bulb.color = color_util.color_rgb_to_hex( *color_util.color_temperature_to_rgb(color_temp)) if (kwargs.get(ATTR_HS_COLOR) is not None and (self._device_type is DeviceTypes.MESH_LIGHT or self._device_type is DeviceTypes.LIGHTSTRIP)): _LOGGER.debug("Setting color") color = color_util.color_rgb_to_hex(*color_util.color_hs_to_RGB( *kwargs.get(ATTR_HS_COLOR))) options.append(create_pid_pair(PropertyIDs.COLOR, str(color))) self._bulb.color = color _LOGGER.debug("Turning on light") loop = asyncio.get_event_loop() loop.create_task(self._bulb_service.turn_on(self._bulb, options)) self._bulb.on = True self._just_updated = True self.async_schedule_update_ha_state()
def _get_rgb_from_properties(self): rgb = self._properties.get("rgb", None) color_mode = self._properties.get("color_mode", None) if not rgb or not color_mode: return rgb color_mode = int(color_mode) if color_mode == 2: # color temperature return color_temperature_to_rgb(self.color_temp) if color_mode == 3: # hsv hue = self._properties.get("hue") sat = self._properties.get("sat") val = self._properties.get("bright") return colorsys.hsv_to_rgb(hue, sat, val) rgb = int(rgb) blue = rgb & 0xff green = (rgb >> 8) & 0xff red = (rgb >> 16) & 0xff return red, green, blue
def _get_rgb_from_properties(self): rgb = self._properties.get('rgb', None) color_mode = self._properties.get('color_mode', None) if not rgb or not color_mode: return rgb color_mode = int(color_mode) if color_mode == 2: # color temperature return color_temperature_to_rgb(self.color_temp) if color_mode == 3: # hsv hue = int(self._properties.get('hue')) sat = int(self._properties.get('sat')) val = int(self._properties.get('bright')) return hsv_to_rgb((hue, sat, val)) rgb = int(rgb) blue = rgb & 0xff green = (rgb >> 8) & 0xff red = (rgb >> 16) & 0xff return red, green, blue
def _get_rgb_from_properties(self): rgb = self._properties.get("rgb", None) color_mode = self._properties.get("color_mode", None) if not rgb or not color_mode: return rgb color_mode = int(color_mode) if color_mode == 2: # color temperature return color_temperature_to_rgb(self.color_temp) if color_mode == 3: # hsv hue = self._properties.get("hue") sat = self._properties.get("sat") val = self._properties.get("bright") return colorsys.hsv_to_rgb(hue, sat, val) rgb = int(rgb) blue = rgb & 0xff green = (rgb >> 8) & 0xff red = (rgb >> 16) & 0xff return red, green, blue
def _get_rgb_from_properties(self): rgb = self._properties.get('rgb', None) color_mode = self._properties.get('color_mode', None) if not rgb or not color_mode: return rgb color_mode = int(color_mode) if color_mode == 2: # color temperature return color_temperature_to_rgb(self.color_temp) if color_mode == 3: # hsv hue = int(self._properties.get('hue')) sat = int(self._properties.get('sat')) val = int(self._properties.get('bright')) return hsv_to_rgb((hue, sat, val)) rgb = int(rgb) blue = rgb & 0xff green = (rgb >> 8) & 0xff red = (rgb >> 16) & 0xff return red, green, blue
async def async_flux_update(self, utcnow=None): """Update all the lights using flux.""" if utcnow is None: utcnow = dt_utcnow() now = as_local(utcnow) sunset = get_astral_event_date(self.hass, SUN_EVENT_SUNSET, now.date()) start_time = self.find_start_time(now) stop_time = self.find_stop_time(now) if stop_time <= start_time: # stop_time does not happen in the same day as start_time if start_time < now: # stop time is tomorrow stop_time += datetime.timedelta(days=1) elif now < start_time: # stop_time was yesterday since the new start_time is not reached stop_time -= datetime.timedelta(days=1) if start_time < now < sunset: # Daytime time_state = "day" temp_range = abs(self._start_colortemp - self._sunset_colortemp) day_length = int(sunset.timestamp() - start_time.timestamp()) seconds_from_start = int(now.timestamp() - start_time.timestamp()) percentage_complete = seconds_from_start / day_length temp_offset = temp_range * percentage_complete if self._start_colortemp > self._sunset_colortemp: temp = self._start_colortemp - temp_offset else: temp = self._start_colortemp + temp_offset else: # Night time time_state = "night" if now < stop_time: if stop_time < start_time and stop_time.day == sunset.day: # we need to use yesterday's sunset time sunset_time = sunset - datetime.timedelta(days=1) else: sunset_time = sunset night_length = int(stop_time.timestamp() - sunset_time.timestamp()) seconds_from_sunset = int(now.timestamp() - sunset_time.timestamp()) percentage_complete = seconds_from_sunset / night_length else: percentage_complete = 1 temp_range = abs(self._sunset_colortemp - self._stop_colortemp) temp_offset = temp_range * percentage_complete if self._sunset_colortemp > self._stop_colortemp: temp = self._sunset_colortemp - temp_offset else: temp = self._sunset_colortemp + temp_offset rgb = color_temperature_to_rgb(temp) x_val, y_val, b_val = color_RGB_to_xy_brightness(*rgb) brightness = self._brightness if self._brightness else b_val if self._disable_brightness_adjust: brightness = None if self._mode == MODE_XY: await async_set_lights_xy(self.hass, self._lights, x_val, y_val, brightness, self._transition) _LOGGER.debug( "Lights updated to x:%s y:%s brightness:%s, %s%% " "of %s cycle complete at %s", x_val, y_val, brightness, round(percentage_complete * 100), time_state, now, ) elif self._mode == MODE_RGB: await async_set_lights_rgb(self.hass, self._lights, rgb, self._transition) _LOGGER.debug( "Lights updated to rgb:%s, %s%% of %s cycle complete at %s", rgb, round(percentage_complete * 100), time_state, now, ) else: # Convert to mired and clamp to allowed values mired = color_temperature_kelvin_to_mired(temp) await async_set_lights_temp(self.hass, self._lights, mired, brightness, self._transition) _LOGGER.debug( "Lights updated to mired:%s brightness:%s, %s%% " "of %s cycle complete at %s", mired, brightness, round(percentage_complete * 100), time_state, now, )
def test_color_above_6600_should_have_more_blue_than_red_or_green(): """Function should return a higher blue value for blue-ish light.""" rgb = color_util.color_temperature_to_rgb(6700) assert rgb[2] > rgb[1] assert rgb[2] > rgb[0]
def test_color_below_6600_should_have_more_red_than_blue_or_green(): """Function should return a higher red value for red-ish light.""" rgb = color_util.color_temperature_to_rgb(6500) assert rgb[0] > rgb[1] assert rgb[0] > rgb[2]
def test_returns_same_value_for_any_two_temperatures_above_40000(): """Function should return same value for 40001K and 999999K.""" rgb_1 = color_util.color_temperature_to_rgb(40001) rgb_2 = color_util.color_temperature_to_rgb(999999) assert rgb_1 == rgb_2
def flux_force_update(self, call=None, entity=None): """Forced update of given or all the lights using flux.""" now = dt_now() if call is None: if entity is None: entity_id = self._lights else: entity_id = entity else: entity_id = call.data.get("entity_id", self._lights) _LOGGER.info("Flux forced update for %s", entity_id) sunset = get_astral_event_date(self.hass, 'sunset', now.date()) start_time = self.find_start_time(now) stop_time = now.replace( hour=self._stop_time.hour, minute=self._stop_time.minute, second=0) if stop_time <= start_time: # stop_time does not happen in the same day as start_time if start_time < now: # stop time is tomorrow stop_time += datetime.timedelta(days=1) elif now < start_time: # stop_time was yesterday since the new start_time is not reached stop_time -= datetime.timedelta(days=1) if start_time < now < sunset: # Daytime time_state = 'day' temp_range = abs(self._start_colortemp - self._sunset_colortemp) day_length = int(sunset.timestamp() - start_time.timestamp()) seconds_from_start = int(now.timestamp() - start_time.timestamp()) percentage_complete = seconds_from_start / day_length temp_offset = temp_range * percentage_complete if self._start_colortemp > self._sunset_colortemp: temp = self._start_colortemp - temp_offset else: temp = self._start_colortemp + temp_offset else: # Nightime time_state = 'night' if now < stop_time: if stop_time < start_time and stop_time.day == sunset.day: # we need to use yesterday's sunset time sunset_time = sunset - datetime.timedelta(days=1) else: sunset_time = sunset # pylint: disable=no-member night_length = int(stop_time.timestamp() - sunset_time.timestamp()) seconds_from_sunset = int(now.timestamp() - sunset_time.timestamp()) percentage_complete = seconds_from_sunset / night_length else: percentage_complete = 1 temp_range = abs(self._sunset_colortemp - self._stop_colortemp) temp_offset = temp_range * percentage_complete if self._sunset_colortemp > self._stop_colortemp: temp = self._sunset_colortemp - temp_offset else: temp = self._sunset_colortemp + temp_offset rgb = color_temperature_to_rgb(temp) x_val, y_val, b_val = color_RGB_to_xy(*rgb) brightness = self._brightness if self._brightness else b_val if self._mode == MODE_XY: _LOGGER.debug("Trying to force update of %s to XY %s, %s", entity_id, x_val, y_val) force_light_xy(self.hass, entity_id, x_val, y_val, brightness) new_color_xy = set_lights_xy(self.hass, self._lights, x_val, y_val, brightness, self._transition, self._last_color) _LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%% " "of %s cycle complete at %s", x_val, y_val, brightness, round( percentage_complete * 100), time_state, now) self._last_color = new_color_xy elif self._mode == MODE_RGB: force_light_rgb(self.hass, entity_id, rgb) new_color_rgb = set_lights_rgb(self.hass, self._lights, rgb, self._transition, self._last_color) _LOGGER.info("Lights updated to rgb:%s, %s%% " "of %s cycle complete at %s", rgb, round(percentage_complete * 100), time_state, now) self._last_color = new_color_rgb else: # Convert to mired and clamp to allowed values mired = color_temperature_kelvin_to_mired(temp) _LOGGER.debug("Trying to force update of %s to mired %s", entity_id, mired) force_light_temp(self.hass, entity_id, mired, brightness) new_colortemp = set_lights_temp(self.hass, self._lights, mired, brightness, self._transition, self._last_color) _LOGGER.info("Lights updated from %s to mired:%s brightness:%s, %s%% " "of %s cycle complete at %s", self._last_color, mired, brightness, round(percentage_complete * 100), time_state, now) self._last_color = new_colortemp
def flux_update(self, now=None): """Update all the lights using flux.""" if now is None: now = dt_now() sunset = get_astral_event_date(self.hass, 'sunset', now.date()) start_time = self.find_start_time(now) stop_time = self.find_stop_time(now) if stop_time <= start_time: # stop_time does not happen in the same day as start_time if start_time < now: # stop time is tomorrow stop_time += datetime.timedelta(days=1) elif now < start_time: # stop_time was yesterday since the new start_time is not reached stop_time -= datetime.timedelta(days=1) if start_time < now < sunset: # Daytime time_state = 'day' temp_range = abs(self._start_colortemp - self._sunset_colortemp) day_length = int(sunset.timestamp() - start_time.timestamp()) seconds_from_start = int(now.timestamp() - start_time.timestamp()) percentage_complete = seconds_from_start / day_length temp_offset = temp_range * percentage_complete if self._start_colortemp > self._sunset_colortemp: temp = self._start_colortemp - temp_offset else: temp = self._start_colortemp + temp_offset else: # Night time time_state = 'night' if now < stop_time: if stop_time < start_time and stop_time.day == sunset.day: # we need to use yesterday's sunset time sunset_time = sunset - datetime.timedelta(days=1) else: sunset_time = sunset # pylint: disable=no-member night_length = int(stop_time.timestamp() - sunset_time.timestamp()) seconds_from_sunset = int(now.timestamp() - sunset_time.timestamp()) percentage_complete = seconds_from_sunset / night_length else: percentage_complete = 1 temp_range = abs(self._sunset_colortemp - self._stop_colortemp) temp_offset = temp_range * percentage_complete if self._sunset_colortemp > self._stop_colortemp: temp = self._sunset_colortemp - temp_offset else: temp = self._sunset_colortemp + temp_offset rgb = color_temperature_to_rgb(temp) x_val, y_val, b_val = color_RGB_to_xy_brightness(*rgb) brightness = self._brightness if self._brightness else b_val if self._disable_brightness_adjust: brightness = None if self._mode == MODE_XY: set_lights_xy(self.hass, self._lights, x_val, y_val, brightness, self._transition) _LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%% " "of %s cycle complete at %s", x_val, y_val, brightness, round( percentage_complete * 100), time_state, now) elif self._mode == MODE_RGB: set_lights_rgb(self.hass, self._lights, rgb, self._transition) _LOGGER.info("Lights updated to rgb:%s, %s%% " "of %s cycle complete at %s", rgb, round(percentage_complete * 100), time_state, now) else: # Convert to mired and clamp to allowed values mired = color_temperature_kelvin_to_mired(temp) set_lights_temp(self.hass, self._lights, mired, brightness, self._transition) _LOGGER.info("Lights updated to mired:%s brightness:%s, %s%% " "of %s cycle complete at %s", mired, brightness, round(percentage_complete * 100), time_state, now)
def test_returns_same_value_for_any_two_temperatures_below_1000(): """Function should return same value for 999 Kelvin and 0 Kelvin.""" rgb_1 = color_util.color_temperature_to_rgb(999) rgb_2 = color_util.color_temperature_to_rgb(0) assert rgb_1 == rgb_2
def test_color_below_6600_should_have_more_red_than_blue_or_green(self): """Function should return a higher red value for red-ish light.""" rgb = color_util.color_temperature_to_rgb(6500) self.assertGreater(rgb[0], rgb[1]) self.assertGreater(rgb[0], rgb[2])
def calc_rgb(self): return color_temperature_to_rgb(self.data['colortemp'])
def calc_rgb(self): return color_temperature_to_rgb(self._color_temperature)
def test_color_above_6600_should_have_more_blue_than_red_or_green(self): """Function should return a higher blue value for blue-ish light.""" rgb = color_util.color_temperature_to_rgb(6700) self.assertGreater(rgb[2], rgb[1]) self.assertGreater(rgb[2], rgb[0])
def test_returns_same_value_for_any_two_temperatures_above_40000(self): """Function should return same value for 40001K and 999999K.""" rgb_1 = color_util.color_temperature_to_rgb(40001) rgb_2 = color_util.color_temperature_to_rgb(999999) self.assertEqual(rgb_1, rgb_2)
def test_returns_same_value_for_any_two_temperatures_below_1000(self): """Function should return same value for 999 Kelvin and 0 Kelvin.""" rgb_1 = color_util.color_temperature_to_rgb(999) rgb_2 = color_util.color_temperature_to_rgb(0) self.assertEqual(rgb_1, rgb_2)
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, adds white value if self._rgbw and any( x in (ATTR_COLOR_TEMP, ATTR_HS_COLOR, ATTR_WHITE_VALUE) for x in kwargs ): # WLED cannot just accept a white value, it needs the color. # We use the last know color in case just the white value changes. if not any(x in (ATTR_COLOR_TEMP, ATTR_HS_COLOR) for x in kwargs): hue, sat = self._color data[ATTR_COLOR_PRIMARY] = color_util.color_hsv_to_RGB(hue, sat, 100) # Add requested or last known white value if ATTR_WHITE_VALUE in kwargs: data[ATTR_COLOR_PRIMARY] += (kwargs[ATTR_WHITE_VALUE],) else: data[ATTR_COLOR_PRIMARY] += (self._white_value,) 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) if ATTR_WHITE_VALUE in kwargs: self._white_value = kwargs[ATTR_WHITE_VALUE] except WLEDError: _LOGGER.error("An error occurred while turning on WLED light.") self._available = False self.async_schedule_update_ha_state()
def ct_to_rgb(temp): """Convert color temperature (mireds) to RGB.""" colorlist = list( color_temperature_to_rgb(color_temperature_mired_to_kelvin(temp))) return [int(val) for val in colorlist]
def flux_update(self, now=None): """Update all the lights using flux.""" if now is None: now = dt_now() sunset = get_astral_event_date(self.hass, 'sunset', now.date()) start_time = self.find_start_time(now) stop_time = now.replace(hour=self._stop_time.hour, minute=self._stop_time.minute, second=0) if stop_time <= start_time: # stop_time does not happen in the same day as start_time if start_time < now: # stop time is tomorrow stop_time += datetime.timedelta(days=1) elif now < start_time: # stop_time was yesterday since the new start_time is not reached stop_time -= datetime.timedelta(days=1) if start_time < now < sunset: # Daytime time_state = 'day' temp_range = abs(self._start_colortemp - self._sunset_colortemp) day_length = int(sunset.timestamp() - start_time.timestamp()) seconds_from_start = int(now.timestamp() - start_time.timestamp()) percentage_complete = seconds_from_start / day_length temp_offset = temp_range * percentage_complete if self._start_colortemp > self._sunset_colortemp: temp = self._start_colortemp - temp_offset else: temp = self._start_colortemp + temp_offset else: # Nightime time_state = 'night' if now < stop_time: if stop_time < start_time and stop_time.day == sunset.day: # we need to use yesterday's sunset time sunset_time = sunset - datetime.timedelta(days=1) else: sunset_time = sunset # pylint: disable=no-member night_length = int(stop_time.timestamp() - sunset_time.timestamp()) seconds_from_sunset = int(now.timestamp() - sunset_time.timestamp()) percentage_complete = seconds_from_sunset / night_length else: percentage_complete = 1 temp_range = abs(self._sunset_colortemp - self._stop_colortemp) temp_offset = temp_range * percentage_complete if self._sunset_colortemp > self._stop_colortemp: temp = self._sunset_colortemp - temp_offset else: temp = self._sunset_colortemp + temp_offset rgb = color_temperature_to_rgb(temp) x_val, y_val, b_val = color_RGB_to_xy(*rgb) brightness = self._brightness if self._brightness else b_val if self._disable_brightness_adjust: brightness = None if self._mode == MODE_XY: set_lights_xy(self.hass, self._lights, x_val, y_val, brightness) _LOGGER.info( "Lights updated to x:%s y:%s brightness:%s, %s%% " "of %s cycle complete at %s", x_val, y_val, brightness, round(percentage_complete * 100), time_state, now) elif self._mode == MODE_RGB: set_lights_rgb(self.hass, self._lights, rgb) _LOGGER.info( "Lights updated to rgb:%s, %s%% " "of %s cycle complete at %s", rgb, round(percentage_complete * 100), time_state, now) else: # Convert to mired and clamp to allowed values mired = color_temperature_kelvin_to_mired(temp) set_lights_temp(self.hass, self._lights, mired, brightness) _LOGGER.info( "Lights updated to mired:%s brightness:%s, %s%% " "of %s cycle complete at %s", mired, brightness, round(percentage_complete * 100), time_state, now)
async def async_turn_on(self, **kwargs: Any) -> None: options = [] if kwargs.get(ATTR_BRIGHTNESS) is not None: brightness = round((kwargs.get(ATTR_BRIGHTNESS) / 255) * 100) options.append(create_pid_pair(PropertyIDs.BRIGHTNESS, str(brightness))) _LOGGER.debug("Setting brightness to %s" % brightness) _LOGGER.debug("Options: %s" % options) self._bulb.brightness = brightness if self._bulb.sun_match: # Turn off sun match if we're changing anything other than brightness if any([kwargs.get(ATTR_COLOR_TEMP, kwargs.get(ATTR_HS_COLOR))]): options.append(create_pid_pair(PropertyIDs.SUN_MATCH, str(0))) self._bulb.sun_match = False _LOGGER.debug("Turning off sun match") if kwargs.get(ATTR_COLOR_TEMP) is not None: _LOGGER.debug("Setting color temp") color_temp = color_util.color_temperature_mired_to_kelvin(kwargs.get(ATTR_COLOR_TEMP)) options.append(create_pid_pair(PropertyIDs.COLOR_TEMP, str(color_temp))) if self._device_type in [DeviceTypes.MESH_LIGHT, DeviceTypes.LIGHTSTRIP]: options.append(create_pid_pair(PropertyIDs.COLOR_MODE, str(2))) # Put bulb in White Mode self._bulb.color_mode = '2' self._bulb.color_temp = color_temp self._bulb.color = color_util.color_rgb_to_hex(*color_util.color_temperature_to_rgb(color_temp)) if ( kwargs.get(ATTR_HS_COLOR) is not None and ( self._device_type is DeviceTypes.MESH_LIGHT or self._device_type is DeviceTypes.LIGHTSTRIP ) ): _LOGGER.debug("Setting color") color = color_util.color_rgb_to_hex(*color_util.color_hs_to_RGB(*kwargs.get(ATTR_HS_COLOR))) options.extend( [ create_pid_pair(PropertyIDs.COLOR, str(color)), create_pid_pair(PropertyIDs.COLOR_MODE, str(1)) # Put bulb in Color Mode ] ) self._bulb.color = color self._bulb.color_mode = '1' if ( kwargs.get(ATTR_EFFECT) == EFFECT_MUSIC_MODE and self._device_type is DeviceTypes.LIGHTSTRIP ): _LOGGER.debug("Setting Music Mode") options.append(create_pid_pair(PropertyIDs.COLOR_MODE, str(3))) self._bulb.color_mode = '3' if kwargs.get(ATTR_EFFECT) == EFFECT_SUN_MATCH: _LOGGER.debug("Setting Sun Match") options.append(create_pid_pair(PropertyIDs.SUN_MATCH, str(1))) self._bulb.sun_match = True _LOGGER.debug("Turning on light") self._local_control = self._config_entry.options.get(BULB_LOCAL_CONTROL) loop = asyncio.get_event_loop() loop.create_task(self._bulb_service.turn_on(self._bulb, self._local_control, options)) self._bulb.on = True self._just_updated = True self.async_schedule_update_ha_state()
def calc_rgb(self): if self.is_sleep(): _LOGGER.debug(self._name + " in Sleep mode") return color_temperature_to_rgb(self._sleep_colortemp) else: return color_temperature_to_rgb(self._cl.data["colortemp"])