Merge pull request #28 from forabi/main

Fix support for BLE TRV

Author: PlusPlus-ua

custom_components/tuya_ble/__init__.py

@@ -23,6 +23,7 @@
     Platform.CLIMATE,
     Platform.NUMBER,
     Platform.SENSOR,
+    Platform.BINARY_SENSOR,
     Platform.SELECT,
     Platform.SWITCH,
 ]

custom_components/tuya_ble/binary_sensor.py

@@ -0,0 +1,164 @@
+"""The Tuya BLE integration."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import logging
+from typing import Callable
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity import EntityCategory
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import (
+    DOMAIN,
+)
+from .devices import TuyaBLEData, TuyaBLEEntity, TuyaBLEProductInfo
+from .tuya_ble import TuyaBLEDataPointType, TuyaBLEDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+SIGNAL_STRENGTH_DP_ID = -1
+
+
+TuyaBLEBinarySensorIsAvailable = (
+    Callable[["TuyaBLEBinarySensor", TuyaBLEProductInfo], bool] | None
+)
+
+
+@dataclass
+class TuyaBLEBinarySensorMapping:
+    dp_id: int
+    description: BinarySensorEntityDescription
+    force_add: bool = True
+    dp_type: TuyaBLEDataPointType | None = None
+    getter: Callable[[TuyaBLEBinarySensor], None] | None = None
+    coefficient: float = 1.0
+    icons: list[str] | None = None
+    is_available: TuyaBLEBinarySensorIsAvailable = None
+
+
+@dataclass
+class TuyaBLECategoryBinarySensorMapping:
+    products: dict[str, list[TuyaBLEBinarySensorMapping]] | None = None
+    mapping: list[TuyaBLEBinarySensorMapping] | None = None
+
+
+mapping: dict[str, TuyaBLECategoryBinarySensorMapping] = {
+    "wk": TuyaBLECategoryBinarySensorMapping(
+        products={
+            "drlajpqc": [  # Thermostatic Radiator Valve
+                TuyaBLEBinarySensorMapping(
+                    dp_id=105,
+                    description=BinarySensorEntityDescription(
+                        key="low_battery",
+                        icon="mdi:battery-alert",
+                        device_class=BinarySensorDeviceClass.BATTERY,
+                        entity_category=EntityCategory.DIAGNOSTIC,
+                        entity_registry_enabled_default=True,
+                    ),
+                ),
+            ],
+        },
+    ),
+}
+
+
+def get_mapping_by_device(device: TuyaBLEDevice) -> list[TuyaBLEBinarySensorMapping]:
+    category = mapping.get(device.category)
+    if category is not None and category.products is not None:
+        product_mapping = category.products.get(device.product_id)
+        if product_mapping is not None:
+            return product_mapping
+        if category.mapping is not None:
+            return category.mapping
+        else:
+            return []
+    else:
+        return []
+
+
+class TuyaBLEBinarySensor(TuyaBLEEntity, BinarySensorEntity):
+    """Representation of a Tuya BLE binary sensor."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        coordinator: DataUpdateCoordinator,
+        device: TuyaBLEDevice,
+        product: TuyaBLEProductInfo,
+        mapping: TuyaBLEBinarySensorMapping,
+    ) -> None:
+        super().__init__(hass, coordinator, device, product, mapping.description)
+        self._mapping = mapping
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        if self._mapping.getter is not None:
+            self._mapping.getter(self)
+        else:
+            datapoint = self._device.datapoints[self._mapping.dp_id]
+            if datapoint:
+                if datapoint.type == TuyaBLEDataPointType.DT_ENUM:
+                    if self.entity_description.options is not None:
+                        if datapoint.value >= 0 and datapoint.value < len(
+                            self.entity_description.options
+                        ):
+                            self._attr_native_value = self.entity_description.options[
+                                datapoint.value
+                            ]
+                        else:
+                            self._attr_native_value = datapoint.value
+                    if self._mapping.icons is not None:
+                        if datapoint.value >= 0 and datapoint.value < len(
+                            self._mapping.icons
+                        ):
+                            self._attr_icon = self._mapping.icons[datapoint.value]
+                elif datapoint.type == TuyaBLEDataPointType.DT_VALUE:
+                    self._attr_native_value = (
+                        datapoint.value / self._mapping.coefficient
+                    )
+                else:
+                    self._attr_native_value = datapoint.value
+        self.async_write_ha_state()
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        result = super().available
+        if result and self._mapping.is_available:
+            result = self._mapping.is_available(self, self._product)
+        return result
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up the Tuya BLE sensors."""
+    data: TuyaBLEData = hass.data[DOMAIN][entry.entry_id]
+    mappings = get_mapping_by_device(data.device)
+    entities: list[TuyaBLEBinarySensor] = []
+    for mapping in mappings:
+        if mapping.force_add or data.device.datapoints.has_id(
+            mapping.dp_id, mapping.dp_type
+        ):
+            entities.append(
+                TuyaBLEBinarySensor(
+                    hass,
+                    data.coordinator,
+                    data.device,
+                    data.product,
+                    mapping,
+                )
+            )
+    async_add_entities(entities)

custom_components/tuya_ble/climate.py

@@ -13,6 +13,7 @@
 from homeassistant.components.climate.const import (
     ClimateEntityFeature,
     HVACMode,
+    HVACAction,
     PRESET_AWAY,
     PRESET_NONE,
 )
@@ -24,7 +25,7 @@
 
 from .const import DOMAIN
 from .devices import TuyaBLEData, TuyaBLEEntity, TuyaBLEProductInfo
-from .tuya_ble import TuyaBLEDataPointType, TuyaBLEDevice
+from .tuya_ble import TuyaBLEDataPoint, TuyaBLEDataPointType, TuyaBLEDevice
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -47,7 +48,7 @@ class TuyaBLEClimateMapping:
     target_temperature_dp_id: int = 0
     target_temperature_coefficient: float = 1.0
     target_temperature_max: float = 30.0
-    target_temperature_min: float = -20.0
+    target_temperature_min: float = 5
     target_temperature_step: float = 1.0
 
     current_humidity_dp_id: int = 0
@@ -67,18 +68,57 @@ class TuyaBLECategoryClimateMapping:
 mapping: dict[str, TuyaBLECategoryClimateMapping] = {
     "wk": TuyaBLECategoryClimateMapping(
         products={
-            "drlajpqc": [  # Thermostatic Radiator Valve
+            "drlajpqc": [
+                # Thermostatic Radiator Valve
+                # - [x] 8   - Window
+                # - [x] 10  - Antifreeze
+                # - [x] 27  - Calibration
+                # - [x] 40  - Lock
+                # - [x] 101 - Switch
+                # - [x] 102 - Current
+                # - [x] 103 - Target
+                # - [ ] 104 - Heating time
+                # - [x] 105 - Battery power alarm
+                # - [x] 106 - Away
+                # - [x] 107 - Programming mode
+                # - [x] 108 - Programming switch
+                # - [ ] 109 - Programming data (deprecated - do not delete)
+                # - [ ] 110 - Historical data protocol (Day-Target temperature)
+                # - [ ] 111 - System Time Synchronization
+                # - [ ] 112 - Historical data (Week-Target temperature)
+                # - [ ] 113 - Historical data (Month-Target temperature)
+                # - [ ] 114 - Historical data (Year-Target temperature)
+                # - [ ] 115 - Historical data (Day-Current temperature)
+                # - [ ] 116 - Historical data (Week-Current temperature)
+                # - [ ] 117 - Historical data (Month-Current temperature)
+                # - [ ] 118 - Historical data (Year-Current temperature)
+                # - [ ] 119 - Historical data (Day-motor opening degree)
+                # - [ ] 120 - Historical data (Week-motor opening degree)
+                # - [ ] 121 - Historical data (Month-motor opening degree)
+                # - [ ] 122 - Historical data (Year-motor opening degree)
+                # - [ ] 123 - Programming data (Monday)
+                # - [ ] 124 - Programming data (Tuseday)
+                # - [ ] 125 - Programming data (Wednesday)
+                # - [ ] 126 - Programming data (Thursday)
+                # - [ ] 127 - Programming data (Friday)
+                # - [ ] 128 - Programming data (Saturday)
+                # - [ ] 129 - Programming data (Sunday)
+                # - [x] 130 - Water scale
                 TuyaBLEClimateMapping(
                     description=ClimateEntityDescription(
                         key="thermostatic_radiator_valve",
                     ),
-                    hvac_switch_dp_id=17,
+                    hvac_switch_dp_id=101,
                     hvac_switch_mode=HVACMode.HEAT,
-                    # preset_mode_dp_ids={PRESET_AWAY: 106},
+                    hvac_modes=[HVACMode.OFF, HVACMode.HEAT],
+                    preset_mode_dp_ids={PRESET_AWAY: 106, PRESET_NONE: 106},
                     current_temperature_dp_id=102,
                     current_temperature_coefficient=10.0,
+                    target_temperature_coefficient=10.0,
+                    target_temperature_step=0.5,
                     target_temperature_dp_id=103,
                     target_temperature_min=5.0,
+                    target_temperature_max=30.0,
                 ),
             ],
         },
@@ -113,7 +153,9 @@ def __init__(
     ) -> None:
         super().__init__(hass, coordinator, device, product, mapping.description)
         self._mapping = mapping
-        self._attr_hvac_mode = HVACMode.OFF
+        self._attr_hvac_mode = HVACMode.HEAT
+        self._attr_preset_mode = PRESET_NONE
+        self._attr_hvac_action = HVACAction.HEATING
 
         if mapping.hvac_mode_dp_id and mapping.hvac_modes:
             self._attr_hvac_modes = mapping.hvac_modes
@@ -185,20 +227,32 @@ def _handle_coordinator_update(self) -> None:
 
         if self._mapping.preset_mode_dp_ids:
             current_preset_mode = PRESET_NONE
-            for preset_mode, dp_id in self._mapping.preset_mode_dp_ids:
+            for preset_mode, dp_id in self._mapping.preset_mode_dp_ids.items():
                 datapoint = self._device.datapoints[dp_id]
                 if datapoint and datapoint.value:
                     current_preset_mode = preset_mode
                     break
             self._attr_preset_mode = current_preset_mode
 
+        try:
+            if (
+                self._attr_preset_mode == PRESET_AWAY
+                or self._attr_hvac_mode == HVACMode.OFF
+                or self._attr_target_temperature <= self._attr_current_temperature
+            ):
+                self._attr_hvac_action = HVACAction.IDLE
+            else:
+                self._attr_hvac_action = HVACAction.HEATING
+        except:
+            pass
+
         self.async_write_ha_state()
 
     async def async_set_temperature(self, **kwargs) -> None:
         """Set new target temperature."""
         if self._mapping.target_temperature_dp_id != 0:
             int_value = int(
-                kwargs["temperature"] * self._mapping.target_humidity_coefficient
+                kwargs["temperature"] * self._mapping.target_temperature_coefficient
             )
             datapoint = self._device.datapoints.get_or_create(
                 self._mapping.target_temperature_dp_id,
@@ -248,15 +302,37 @@ async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set new preset mode."""
         if self._mapping.preset_mode_dp_ids:
-            for dp_preset_mode, dp_id in self._mapping.preset_mode_dp_ids:
-                bool_value = dp_preset_mode == preset_mode
-                datapoint = self._device.datapoints.get_or_create(
-                    dp_id,
-                    TuyaBLEDataPointType.DT_BOOL,
-                    bool_value,
-                )
-                if datapoint:
-                    self._hass.create_task(datapoint.set_value(bool_value))
+            datapoint: TuyaBLEDataPoint | None = None
+            bool_value = False
+
+            keys = [x for x in self._mapping.preset_mode_dp_ids.keys()]
+            values = [
+                x for x in self._mapping.preset_mode_dp_ids.values()
+            ]  # Get all DP IDs
+            # TRVs with only Away and None modes can be set with a single datapoint and use a single DP ID
+            if all(values[0] == elem for elem in values) and keys[0] == PRESET_AWAY:
+                for dp_id in values:
+                    bool_value = preset_mode == PRESET_AWAY
+                    datapoint = self._device.datapoints.get_or_create(
+                        dp_id,
+                        TuyaBLEDataPointType.DT_BOOL,
+                        bool_value,
+                    )
+                    break
+            else:
+                if self._mapping.preset_mode_dp_ids:
+                    for (
+                        dp_preset_mode,
+                        dp_id,
+                    ) in self._mapping.preset_mode_dp_ids.items():
+                        bool_value = dp_preset_mode == preset_mode
+                        datapoint = self._device.datapoints.get_or_create(
+                            dp_id,
+                            TuyaBLEDataPointType.DT_BOOL,
+                            bool_value,
+                        )
+            if datapoint:
+                self._hass.create_task(datapoint.set_value(bool_value))
 
 
 async def async_setup_entry(

custom_components/tuya_ble/const.py

@@ -37,3 +37,4 @@
 FINGERBOT_MODE_PUSH: Final = "push"
 FINGERBOT_MODE_SWITCH: Final = "switch"
 FINGERBOT_BUTTON_EVENT: Final = "fingerbot_button_pressed"
+

custom_components/tuya_ble/devices.py

@@ -7,7 +7,11 @@
 
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.entity import DeviceInfo, EntityDescription
+from homeassistant.helpers.entity import (
+    DeviceInfo,
+    EntityDescription,
+    generate_entity_id,
+)
 from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
@@ -73,6 +77,9 @@ def __init__(
         self._attr_has_entity_name = True
         self._attr_device_info = get_device_info(self._device)
         self._attr_unique_id = f"{self._device.device_id}-{description.key}"
+        self.entity_id = generate_entity_id(
+            "sensor.{}", self._attr_unique_id, hass=hass
+        )
 
     @property
     def available(self) -> bool:

custom_components/tuya_ble/manifest.json

@@ -11,7 +11,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters", "tuya"],
   "documentation": "https://www.home-assistant.io/integrations/tuya_ble",
-  "requirements": ["tuya-iot-py-sdk==0.6.6", "pycountry"],
+  "requirements": ["tuya-iot-py-sdk==0.6.6", "pycountry==22.3.5"],
   "iot_class": "local_push",
   "version": "0.1.6"
 }