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

766 lines
26 KiB
Python
Raw Permalink Blame History

"""Support for the Tuya lights."""
from __future__ import annotations
from dataclasses import dataclass, field
import json
from typing import Any, cast
from tuya_sharing import CustomerDevice, Manager
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP_KELVIN,
ATTR_HS_COLOR,
ATTR_WHITE,
ColorMode,
LightEntity,
LightEntityDescription,
color_supported,
filter_supported_color_modes,
)
from homeassistant.const import EntityCategory
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
from homeassistant.util import color as color_util
from . import TuyaConfigEntry
from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode, DPType, WorkMode
from .entity import TuyaEntity
from .models import IntegerTypeData
from .util import get_dpcode, remap_value
@dataclass
class ColorTypeData:
"""Color Type Data."""
h_type: IntegerTypeData
s_type: IntegerTypeData
v_type: IntegerTypeData
DEFAULT_COLOR_TYPE_DATA = ColorTypeData(
h_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=360, step=1),
s_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=255, step=1),
v_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=255, step=1),
)
DEFAULT_COLOR_TYPE_DATA_V2 = ColorTypeData(
h_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=360, step=1),
s_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=1000, step=1),
v_type=IntegerTypeData(DPCode.COLOUR_DATA_HSV, min=1, scale=0, max=1000, step=1),
)
MAX_MIREDS = 500 # 2000 K
MIN_MIREDS = 153 # 6500 K
@dataclass(frozen=True)
class TuyaLightEntityDescription(LightEntityDescription):
"""Describe an Tuya light entity."""
brightness_max: DPCode | None = None
brightness_min: DPCode | None = None
brightness: DPCode | tuple[DPCode, ...] | None = None
color_data: DPCode | tuple[DPCode, ...] | None = None
color_mode: DPCode | None = None
color_temp: DPCode | tuple[DPCode, ...] | None = None
default_color_type: ColorTypeData = field(
default_factory=lambda: DEFAULT_COLOR_TYPE_DATA
)
LIGHTS: dict[DeviceCategory, tuple[TuyaLightEntityDescription, ...]] = {
DeviceCategory.BZYD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.CLKG: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_BACKLIGHT,
translation_key="backlight",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.DC: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.DD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
default_color_type=DEFAULT_COLOR_TYPE_DATA_V2,
),
),
DeviceCategory.DJ: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=(DPCode.BRIGHT_VALUE_V2, DPCode.BRIGHT_VALUE),
color_temp=(DPCode.TEMP_VALUE_V2, DPCode.TEMP_VALUE),
color_data=(DPCode.COLOUR_DATA_V2, DPCode.COLOUR_DATA),
),
# Not documented
# Based on multiple reports: manufacturer customized Dimmer 2 switches
TuyaLightEntityDescription(
key=DPCode.SWITCH_1,
translation_key="indexed_light",
translation_placeholders={"index": "1"},
brightness=DPCode.BRIGHT_VALUE_1,
),
),
DeviceCategory.DSD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
),
),
DeviceCategory.FS: (
TuyaLightEntityDescription(
key=DPCode.LIGHT,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
),
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
translation_key="indexed_light",
translation_placeholders={"index": "2"},
brightness=DPCode.BRIGHT_VALUE_1,
),
),
DeviceCategory.FSD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
# Some ceiling fan lights use LIGHT for DPCode instead of SWITCH_LED
TuyaLightEntityDescription(
key=DPCode.LIGHT,
name=None,
),
),
DeviceCategory.FWD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.GYD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.HXD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
translation_key="light",
brightness=(DPCode.BRIGHT_VALUE_V2, DPCode.BRIGHT_VALUE),
brightness_max=DPCode.BRIGHTNESS_MAX_1,
brightness_min=DPCode.BRIGHTNESS_MIN_1,
),
),
DeviceCategory.JSQ: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_data=DPCode.COLOUR_DATA_HSV,
),
),
DeviceCategory.KG: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_BACKLIGHT,
translation_key="backlight",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.KJ: (
TuyaLightEntityDescription(
key=DPCode.LIGHT,
translation_key="backlight",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.KT: (
TuyaLightEntityDescription(
key=DPCode.LIGHT,
translation_key="backlight",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.KS: (
TuyaLightEntityDescription(
key=DPCode.LIGHT,
translation_key="backlight",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.MBD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.QJDCZ: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.QN: (
TuyaLightEntityDescription(
key=DPCode.LIGHT,
translation_key="backlight",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.SP: (
TuyaLightEntityDescription(
key=DPCode.FLOODLIGHT_SWITCH,
brightness=DPCode.FLOODLIGHT_LIGHTNESS,
name="Floodlight",
),
TuyaLightEntityDescription(
key=DPCode.BASIC_INDICATOR,
name="Indicator light",
entity_category=EntityCategory.CONFIG,
),
),
DeviceCategory.SZ: (
TuyaLightEntityDescription(
key=DPCode.LIGHT,
brightness=DPCode.BRIGHT_VALUE,
translation_key="light",
),
),
DeviceCategory.TGKG: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED_1,
translation_key="indexed_light",
translation_placeholders={"index": "1"},
brightness=DPCode.BRIGHT_VALUE_1,
brightness_max=DPCode.BRIGHTNESS_MAX_1,
brightness_min=DPCode.BRIGHTNESS_MIN_1,
),
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED_2,
translation_key="indexed_light",
translation_placeholders={"index": "2"},
brightness=DPCode.BRIGHT_VALUE_2,
brightness_max=DPCode.BRIGHTNESS_MAX_2,
brightness_min=DPCode.BRIGHTNESS_MIN_2,
),
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED_3,
translation_key="indexed_light",
translation_placeholders={"index": "3"},
brightness=DPCode.BRIGHT_VALUE_3,
brightness_max=DPCode.BRIGHTNESS_MAX_3,
brightness_min=DPCode.BRIGHTNESS_MIN_3,
),
),
DeviceCategory.TGQ: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
translation_key="light",
brightness=(DPCode.BRIGHT_VALUE_V2, DPCode.BRIGHT_VALUE),
brightness_max=DPCode.BRIGHTNESS_MAX_1,
brightness_min=DPCode.BRIGHTNESS_MIN_1,
),
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED_1,
translation_key="indexed_light",
translation_placeholders={"index": "1"},
brightness=DPCode.BRIGHT_VALUE_1,
),
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED_2,
translation_key="indexed_light",
translation_placeholders={"index": "2"},
brightness=DPCode.BRIGHT_VALUE_2,
),
),
DeviceCategory.TYD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.TYNDJ: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
),
DeviceCategory.XDD: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_LED,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_VALUE,
color_temp=DPCode.TEMP_VALUE,
color_data=DPCode.COLOUR_DATA,
),
TuyaLightEntityDescription(
key=DPCode.SWITCH_NIGHT_LIGHT,
translation_key="night_light",
),
),
DeviceCategory.YKQ: (
TuyaLightEntityDescription(
key=DPCode.SWITCH_CONTROLLER,
name=None,
color_mode=DPCode.WORK_MODE,
brightness=DPCode.BRIGHT_CONTROLLER,
color_temp=DPCode.TEMP_CONTROLLER,
),
),
}
# Socket (duplicate of `kg`)
# https://developer.tuya.com/en/docs/iot/s?id=K9gf7o5prgf7s
LIGHTS[DeviceCategory.CZ] = LIGHTS[DeviceCategory.KG]
# Power Socket (duplicate of `kg`)
LIGHTS[DeviceCategory.PC] = LIGHTS[DeviceCategory.KG]
# Smart Camera - Low power consumption camera (duplicate of `sp`)
LIGHTS[DeviceCategory.DGHSXJ] = LIGHTS[DeviceCategory.SP]
# Dimmer (duplicate of `tgq`)
LIGHTS[DeviceCategory.TDQ] = LIGHTS[DeviceCategory.TGQ]
@dataclass
class ColorData:
"""Color Data."""
type_data: ColorTypeData
h_value: int
s_value: int
v_value: int
@property
def hs_color(self) -> tuple[float, float]:
"""Get the HS value from this color data."""
return (
self.type_data.h_type.remap_value_to(self.h_value, 0, 360),
self.type_data.s_type.remap_value_to(self.s_value, 0, 100),
)
@property
def brightness(self) -> int:
"""Get the brightness value from this color data."""
return round(self.type_data.v_type.remap_value_to(self.v_value, 0, 255))
async def async_setup_entry(
hass: HomeAssistant,
entry: TuyaConfigEntry,
async_add_entities: AddConfigEntryEntitiesCallback,
) -> None:
"""Set up tuya light dynamically through tuya discovery."""
manager = entry.runtime_data.manager
@callback
def async_discover_device(device_ids: list[str]):
"""Discover and add a discovered tuya light."""
entities: list[TuyaLightEntity] = []
for device_id in device_ids:
device = manager.device_map[device_id]
if descriptions := LIGHTS.get(device.category):
entities.extend(
TuyaLightEntity(device, manager, description)
for description in descriptions
if description.key in device.status
)
async_add_entities(entities)
async_discover_device([*manager.device_map])
entry.async_on_unload(
async_dispatcher_connect(hass, TUYA_DISCOVERY_NEW, async_discover_device)
)
class TuyaLightEntity(TuyaEntity, LightEntity):
"""Tuya light device."""
entity_description: TuyaLightEntityDescription
_brightness_max: IntegerTypeData | None = None
_brightness_min: IntegerTypeData | None = None
_brightness: IntegerTypeData | None = None
_color_data_dpcode: DPCode | None = None
_color_data_type: ColorTypeData | None = None
_color_mode: DPCode | None = None
_color_temp: IntegerTypeData | None = None
_white_color_mode = ColorMode.COLOR_TEMP
_fixed_color_mode: ColorMode | None = None
_attr_min_color_temp_kelvin = 2000 # 500 Mireds
_attr_max_color_temp_kelvin = 6500 # 153 Mireds
def __init__(
self,
device: CustomerDevice,
device_manager: Manager,
description: TuyaLightEntityDescription,
) -> None:
"""Init TuyaHaLight."""
super().__init__(device, device_manager)
self.entity_description = description
self._attr_unique_id = f"{super().unique_id}{description.key}"
color_modes: set[ColorMode] = {ColorMode.ONOFF}
# Determine DPCodes
self._color_mode_dpcode = get_dpcode(self.device, description.color_mode)
if int_type := self.find_dpcode(
description.brightness, dptype=DPType.INTEGER, prefer_function=True
):
self._brightness = int_type
color_modes.add(ColorMode.BRIGHTNESS)
self._brightness_max = self.find_dpcode(
description.brightness_max, dptype=DPType.INTEGER
)
self._brightness_min = self.find_dpcode(
description.brightness_min, dptype=DPType.INTEGER
)
if (
dpcode := get_dpcode(self.device, description.color_data)
) and self.get_dptype(dpcode, prefer_function=True) == DPType.JSON:
self._color_data_dpcode = dpcode
color_modes.add(ColorMode.HS)
if dpcode in self.device.function:
values = cast(str, self.device.function[dpcode].values)
else:
values = self.device.status_range[dpcode].values
# Fetch color data type information
if function_data := json.loads(values):
self._color_data_type = ColorTypeData(
h_type=IntegerTypeData(dpcode, **function_data["h"]),
s_type=IntegerTypeData(dpcode, **function_data["s"]),
v_type=IntegerTypeData(dpcode, **function_data["v"]),
)
else:
# If no type is found, use a default one
self._color_data_type = self.entity_description.default_color_type
if self._color_data_dpcode == DPCode.COLOUR_DATA_V2 or (
self._brightness and self._brightness.max > 255
):
self._color_data_type = DEFAULT_COLOR_TYPE_DATA_V2
# Check if the light has color temperature
if int_type := self.find_dpcode(
description.color_temp, dptype=DPType.INTEGER, prefer_function=True
):
self._color_temp = int_type
color_modes.add(ColorMode.COLOR_TEMP)
# If light has color but does not have color_temp, check if it has
# work_mode "white"
elif (
color_supported(color_modes)
and (
color_mode_enum := self.find_dpcode(
description.color_mode, dptype=DPType.ENUM, prefer_function=True
)
)
and WorkMode.WHITE.value in color_mode_enum.range
):
color_modes.add(ColorMode.WHITE)
self._white_color_mode = ColorMode.WHITE
self._attr_supported_color_modes = filter_supported_color_modes(color_modes)
if len(self._attr_supported_color_modes) == 1:
# If the light supports only a single color mode, set it now
self._fixed_color_mode = next(iter(self._attr_supported_color_modes))
@property
def is_on(self) -> bool:
"""Return true if light is on."""
return self.device.status.get(self.entity_description.key, False)
def turn_on(self, **kwargs: Any) -> None:
"""Turn on or control the light."""
commands = [{"code": self.entity_description.key, "value": True}]
if self._color_mode_dpcode and (
ATTR_WHITE in kwargs or ATTR_COLOR_TEMP_KELVIN in kwargs
):
commands += [
{
"code": self._color_mode_dpcode,
"value": WorkMode.WHITE,
},
]
if self._color_temp and ATTR_COLOR_TEMP_KELVIN in kwargs:
commands += [
{
"code": self._color_temp.dpcode,
"value": round(
self._color_temp.remap_value_from(
color_util.color_temperature_kelvin_to_mired(
kwargs[ATTR_COLOR_TEMP_KELVIN]
),
MIN_MIREDS,
MAX_MIREDS,
reverse=True,
)
),
},
]
if self._color_data_type and (
ATTR_HS_COLOR in kwargs
or (
ATTR_BRIGHTNESS in kwargs
and self.color_mode == ColorMode.HS
and ATTR_WHITE not in kwargs
and ATTR_COLOR_TEMP_KELVIN not in kwargs
)
):
if self._color_mode_dpcode:
commands += [
{
"code": self._color_mode_dpcode,
"value": WorkMode.COLOUR,
},
]
if not (brightness := kwargs.get(ATTR_BRIGHTNESS)):
brightness = self.brightness or 0
if not (color := kwargs.get(ATTR_HS_COLOR)):
color = self.hs_color or (0, 0)
commands += [
{
"code": self._color_data_dpcode,
"value": json.dumps(
{
"h": round(
self._color_data_type.h_type.remap_value_from(
color[0], 0, 360
)
),
"s": round(
self._color_data_type.s_type.remap_value_from(
color[1], 0, 100
)
),
"v": round(
self._color_data_type.v_type.remap_value_from(
brightness
)
),
}
),
},
]
elif self._brightness and (ATTR_BRIGHTNESS in kwargs or ATTR_WHITE in kwargs):
if ATTR_BRIGHTNESS in kwargs:
brightness = kwargs[ATTR_BRIGHTNESS]
else:
brightness = kwargs[ATTR_WHITE]
# If there is a min/max value, the brightness is actually limited.
# Meaning it is actually not on a 0-255 scale.
if (
self._brightness_max is not None
and self._brightness_min is not None
and (
brightness_max := self.device.status.get(
self._brightness_max.dpcode
)
)
is not None
and (
brightness_min := self.device.status.get(
self._brightness_min.dpcode
)
)
is not None
):
# Remap values onto our scale
brightness_max = self._brightness_max.remap_value_to(brightness_max)
brightness_min = self._brightness_min.remap_value_to(brightness_min)
# Remap the brightness value from their min-max to our 0-255 scale
brightness = remap_value(
brightness,
to_min=brightness_min,
to_max=brightness_max,
)
commands += [
{
"code": self._brightness.dpcode,
"value": round(self._brightness.remap_value_from(brightness)),
},
]
self._send_command(commands)
def turn_off(self, **kwargs: Any) -> None:
"""Instruct the light to turn off."""
self._send_command([{"code": self.entity_description.key, "value": False}])
@property
def brightness(self) -> int | None:
"""Return the brightness of the light."""
# If the light is currently in color mode, extract the brightness from the color data
if self.color_mode == ColorMode.HS and (color_data := self._get_color_data()):
return color_data.brightness
if not self._brightness:
return None
brightness = self.device.status.get(self._brightness.dpcode)
if brightness is None:
return None
# Remap value to our scale
brightness = self._brightness.remap_value_to(brightness)
# If there is a min/max value, the brightness is actually limited.
# Meaning it is actually not on a 0-255 scale.
if (
self._brightness_max is not None
and self._brightness_min is not None
and (brightness_max := self.device.status.get(self._brightness_max.dpcode))
is not None
and (brightness_min := self.device.status.get(self._brightness_min.dpcode))
is not None
):
# Remap values onto our scale
brightness_max = self._brightness_max.remap_value_to(brightness_max)
brightness_min = self._brightness_min.remap_value_to(brightness_min)
# Remap the brightness value from their min-max to our 0-255 scale
brightness = remap_value(
brightness,
from_min=brightness_min,
from_max=brightness_max,
)
return round(brightness)
@property
def color_temp_kelvin(self) -> int | None:
"""Return the color temperature value in Kelvin."""
if not self._color_temp:
return None
temperature = self.device.status.get(self._color_temp.dpcode)
if temperature is None:
return None
return color_util.color_temperature_mired_to_kelvin(
self._color_temp.remap_value_to(
temperature, MIN_MIREDS, MAX_MIREDS, reverse=True
)
)
@property
def hs_color(self) -> tuple[float, float] | None:
"""Return the hs_color of the light."""
if self._color_data_dpcode is None or not (
color_data := self._get_color_data()
):
return None
return color_data.hs_color
@property
def color_mode(self) -> ColorMode:
"""Return the color_mode of the light."""
if self._fixed_color_mode:
# The light supports only a single color mode, return it
return self._fixed_color_mode
# The light supports both white (with or without adjustable color temperature)
# and HS, determine which mode the light is in. We consider it to be in HS color
# mode, when work mode is anything else than "white".
if (
self._color_mode_dpcode
and self.device.status.get(self._color_mode_dpcode) != WorkMode.WHITE
):
return ColorMode.HS
return self._white_color_mode
def _get_color_data(self) -> ColorData | None:
"""Get current color data from device."""
if (
self._color_data_type is None
or self._color_data_dpcode is None
or self._color_data_dpcode not in self.device.status
):
return None
if not (status_data := self.device.status[self._color_data_dpcode]):
return None
if not (status := json.loads(status_data)):
return None
return ColorData(
type_data=self._color_data_type,
h_value=status["h"],
s_value=status["s"],
v_value=status["v"],
)
Reference in New Issue View Git Blame Copy Permalink