feat: version v0.1.14

feat: Add COLMO Turing Central AC

README.md

@@ -1,60 +1,65 @@
 # Midea Auto Cloud
 
- [![Stable](https://img.shields.io/github/v/release/sususweet/midea-meiju-codec)](https://github.com/sususweet/midea-meiju-codec/releases/latest)
+[![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg)](https://github.com/hacs/integration)
+[![Stable](https://img.shields.io/github/v/release/sususweet/midea-meiju-codec)](https://github.com/sususweet/midea-meiju-codec/releases/latest)
 
-通过网络获取你美居家庭中的设备，并且通过美的云端进行控制。
+English | [简体中文](README_zh_CN.md)
 
-- 自动查找和发现设备
-- 自动下载设备的协议文件
-- 将设备状态更新为设备可见的属性
+Get devices from MSmartHome/Midea Meiju homes through the network and control them via Midea's cloud API.
 
-## 版本说明
+- Automatically discover and find devices
+- Automatically download device protocol files
+- Update device status to visible device attributes
 
-- 所有设备默认可生成一个名为Status的二进制传感器，其属性中列出了设备可访问的所有属性，当然有些值不可设置
-- Status实体前几项列出了该设备的分类信息，供参考
+## Version Notes
 
-## 目前支持的设备类型
+- All devices can generate a binary sensor named "Status" by default, which lists all accessible device attributes in its properties (some values are not settable)
+- The first few items of the Status entity list the device classification information for reference
 
-- T0x13 电灯
-- T0x21 中央空调网关
-- T0x26 浴霸
-- T0xA1 除湿机
-- T0xAC 空调
-- T0xB2 电蒸箱
-- T0xB3 消毒碗柜
-- T0xB6 抽油烟机
-- T0xB7 燃气灶
-- T0xB8 智能扫地机器人
-- T0xCA 对开门冰箱
-- T0xCC 中央空调(风管机)Wi-Fi线控器
-- T0xCE 新风机
-- T0xCF 中央空调暖家
-- T0xD9 复式洗衣机
-- T0xDB 滚筒洗衣机
-- T0xDC 干衣机
-- T0xE1 洗碗机
-- T0xE2 电热水器
-- T0xE3 恒温式燃气热水器
-- T0xEA 电饭锅
-- T0xED 软水机
-- T0xFA 电风扇
-- T0xFD 加湿器
+## Currently Supported Device Types
 
-欢迎合作开发添加更多设备支持。
+- T0x13 Electric Light
+- T0x21 Central Air Conditioning Gateway
+- T0x26 Bath Heater
+- T0x3D Water Heater
+- T0xA1 Dehumidifier
+- T0xAC Air Conditioner
+- T0xB2 Electric Steamer
+- T0xB3 Disinfection Cabinet
+- T0xB6 Range Hood
+- T0xB7 Gas Stove
+- T0xB8 Smart Robot Vacuum
+- T0xCA French Door Refrigerator
+- T0xCC Central Air Conditioning (Ducted) Wi-Fi Controller
+- T0xCE Fresh Air System
+- T0xCF Central Air Conditioning Heating
+- T0xD9 Twin Tub Washing Machine
+- T0xDB Front Load Washing Machine
+- T0xDC Clothes Dryer
+- T0xE1 Dishwasher
+- T0xE2 Electric Water Heater
+- T0xE3 Constant Temperature Gas Water Heater
+- T0xEA Rice Cooker
+- T0xED Water Softener
+- T0xFA Electric Fan
+- T0xFB Electric Heater
+- T0xFD Humidifier
 
-合作开发方法：添加本插件后，找到未能正确识别的设备，点击对应设备`传感器`分类下的`连通性`：
+Welcome to collaborate on adding support for more devices.
+
+Collaboration method: After adding this plugin, find devices that are not correctly identified, click on `Connectivity` under the `Sensor` category of the corresponding device:
 
 ![img.png](./img/img.png)
 
-展开下面的`属性`卡片，把里面这些字段随issue提交。 着重关注Device type、Subtype这两个字段，这是后续获得设备控制对应lua文件的基础。
+Expand the `Attributes` card below and submit these fields with the issue. Pay special attention to the `Device type` and `Subtype` fields, as these are the basis for obtaining the corresponding lua files for device control.
 
-再进入Homeassistant的安装目录， 在`.storage/midea_auto_cloud/lua/`目录下找到设备对应的T_0000_`Device type`_`Subtype`_***.lua文件，等待适配就可以了。
+Then go to the Home Assistant installation directory, find the device's corresponding T_0000_`Device type`_`Subtype`_***.lua file in the `.storage/midea_auto_cloud/lua/` directory, and wait for adaptation.
 
 ![img_1.png](./img/img_1.png)
 
-## 实体映射
+## Entity Mapping
 
-映射文件位于`device_mapping`下, 每个大的品类一个映射文件，目前支持映射的实体类型如下:
+Mapping files are located under `device_mapping`, with one mapping file for each major category. Currently supported entity types for mapping are:
 - sensor
 - binary_sensor
 - switch
@@ -63,8 +68,8 @@
 - fan
 - water_heater
 
-示例配置`22012227`演示了如何将设备属性映射成以上各种HomeAssistant中的实体。
+The example configuration `22012227` demonstrates how to map device attributes to various Home Assistant entities above.
 
-## 致谢
+## Acknowledgments
 
-感谢[midea-meiju-codec](https://github.com/MattedBroadSky/midea-meiju-codec)项目提供的先验知识。
+Thanks to the [midea-meiju-codec](https://github.com/MattedBroadSky/midea-meiju-codec) project for providing prior knowledge.

README_zh_CN.md

@@ -0,0 +1,75 @@
+# Midea Auto Cloud
+
+[![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg)](https://github.com/hacs/integration)
+[![Stable](https://img.shields.io/github/v/release/sususweet/midea-meiju-codec)](https://github.com/sususweet/midea-meiju-codec/releases/latest)
+
+[English](README.md) | 简体中文
+
+通过网络获取 MSmartHome/美的美居 家庭中的设备，并且通过美的云端API进行控制。
+
+- 自动查找和发现设备
+- 自动下载设备的协议文件
+- 将设备状态更新为设备可见的属性
+
+## 版本说明
+
+- 所有设备默认可生成一个名为Status的二进制传感器，其属性中列出了设备可访问的所有属性，当然有些值不可设置
+- Status实体前几项列出了该设备的分类信息，供参考
+
+## 目前支持的设备类型
+
+- T0x13 电灯
+- T0x21 中央空调网关
+- T0x26 浴霸 
+- T0x3D 电热水瓶
+- T0xA1 除湿机
+- T0xAC 空调
+- T0xB2 电蒸箱
+- T0xB3 消毒碗柜
+- T0xB6 抽油烟机
+- T0xB7 燃气灶
+- T0xB8 智能扫地机器人
+- T0xCA 对开门冰箱
+- T0xCC 中央空调(风管机)Wi-Fi线控器
+- T0xCE 新风机
+- T0xCF 中央空调暖家
+- T0xD9 复式洗衣机
+- T0xDB 滚筒洗衣机
+- T0xDC 干衣机
+- T0xE1 洗碗机
+- T0xE2 电热水器
+- T0xE3 恒温式燃气热水器
+- T0xEA 电饭锅
+- T0xED 软水机
+- T0xFA 电风扇
+- T0xFB 电暖器
+- T0xFD 加湿器
+
+欢迎合作开发添加更多设备支持。
+
+合作开发方法：添加本插件后，找到未能正确识别的设备，点击对应设备`传感器`分类下的`连通性`：
+
+![img.png](./img/img.png)
+
+展开下面的`属性`卡片，把里面这些字段随issue提交。 着重关注Device type、Subtype这两个字段，这是后续获得设备控制对应lua文件的基础。
+
+再进入Homeassistant的安装目录， 在`.storage/midea_auto_cloud/lua/`目录下找到设备对应的T_0000_`Device type`_`Subtype`_***.lua文件，等待适配就可以了。
+
+![img_1.png](./img/img_1.png)
+
+## 实体映射
+
+映射文件位于`device_mapping`下, 每个大的品类一个映射文件，目前支持映射的实体类型如下:
+- sensor
+- binary_sensor
+- switch
+- select
+- climate
+- fan
+- water_heater
+
+示例配置`22012227`演示了如何将设备属性映射成以上各种HomeAssistant中的实体。
+
+## 致谢
+
+感谢[midea-meiju-codec](https://github.com/MattedBroadSky/midea-meiju-codec)项目提供的先验知识。

custom_components/midea_auto_cloud/__init__.py

@@ -1,6 +1,7 @@
 import os
 import base64
 from importlib import import_module
+import re
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.util.json import load_json
 
@@ -96,16 +97,22 @@ async def load_device_config(hass: HomeAssistant, device_type, sn8):
     #         # 如果像映射体（包含 entities/centralized 等关键字段），直接使用
     #         if any(k in raw for k in ["entities", "centralized", "queries", "manufacturer"]):
     #             json_data = raw
-    if not json_data:
-        device_path = f".device_mapping.{'T0x%02X' % device_type}"
-        try:
-            mapping_module = import_module(device_path, __package__)
-            if sn8 in mapping_module.DEVICE_MAPPING.keys():
-                json_data = mapping_module.DEVICE_MAPPING[sn8]
-            elif "default" in mapping_module.DEVICE_MAPPING:
+    # if not json_data:
+    device_path = f".device_mapping.{'T0x%02X' % device_type}"
+    try:
+        mapping_module = import_module(device_path, __package__)
+        for key, config in mapping_module.DEVICE_MAPPING.items():
+            # support tuple & regular expression pattern to support multiple sn8 sharing one mapping
+            if (key == sn8) or (isinstance(key, tuple) and sn8 in key) or (isinstance(key, str) and re.match(key, sn8)):
+                json_data = config
+                break
+        if not json_data:
+            if "default" in mapping_module.DEVICE_MAPPING:
                 json_data = mapping_module.DEVICE_MAPPING["default"]
-        except ModuleNotFoundError:
-            MideaLogger.warning(f"Can't load mapping file for type {'T0x%02X' % device_type}")
+            else:
+                MideaLogger.warning(f"No mapping found for sn8 {sn8} in type {'T0x%02X' % device_type}")
+    except ModuleNotFoundError:
+        MideaLogger.warning(f"Can't load mapping file for type {'T0x%02X' % device_type}")
 
     save_data = {sn8: json_data}
     # offload save_json as well

custom_components/midea_auto_cloud/climate.py

@@ -79,6 +79,10 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
         self._key_max_temp = self._config.get("max_temp")
         self._key_current_temperature = self._config.get("current_temperature")
         self._key_target_temperature = self._config.get("target_temperature")
+        self._key_min_humidity = self._config.get("min_humidity")
+        self._key_max_humidity = self._config.get("max_humidity")
+        self._key_current_humidity = self._config.get("current_humidity")
+        self._key_target_humidity = self._config.get("target_humidity")
         self._attr_temperature_unit = self._config.get("temperature_unit")
         self._attr_precision = self._config.get("precision")
 
@@ -89,6 +93,8 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
         features |= ClimateEntityFeature.TURN_OFF
         if self._key_target_temperature is not None:
             features |= ClimateEntityFeature.TARGET_TEMPERATURE
+        if self._key_target_humidity is not None:
+            features |= ClimateEntityFeature.TARGET_HUMIDITY
         if self._key_preset_modes is not None:
             features |= ClimateEntityFeature.PRESET_MODE
         # if self._key_aux_heat is not None:
@@ -137,6 +143,28 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
                         return None
                 return None
 
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        humidity = self._get_nested_value(self._key_current_humidity)
+        if humidity is not None:
+            try:
+                return float(humidity)
+            except (ValueError, TypeError):
+                return None
+        return None
+
+    @property
+    def target_humidity(self) -> float | None:
+        """Return the humidity we try to reach."""
+        humidity = self._get_nested_value(self._key_target_humidity)
+        if humidity is not None:
+            try:
+                return float(humidity)
+            except (ValueError, TypeError):
+                return None
+        return None
+
     @property
     def min_temp(self):
         if isinstance(self._key_min_temp, str):
@@ -151,6 +179,20 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
         else:
             return float(self._key_max_temp)
 
+    @property
+    def min_humidity(self):
+        if isinstance(self._key_min_humidity, str):
+            return float(self.device_attributes.get(self._key_min_humidity, 45))
+        else:
+            return float(self._key_min_humidity)
+
+    @property
+    def max_humidity(self):
+        if isinstance(self._key_max_humidity, str):
+            return float(self.device_attributes.get(self._key_max_humidity, 65))
+        else:
+            return float(self._key_max_humidity)
+
     @property
     def target_temperature_low(self):
         return self.min_temp
@@ -159,6 +201,14 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
     def target_temperature_high(self):
         return self.max_temp
 
+    @property
+    def target_humidity_low(self):
+        return self.min_humidity
+
+    @property
+    def target_humidity_high(self):
+        return self.max_humidity
+
     @property
     def preset_modes(self):
         return list(self._key_preset_modes.keys())
@@ -253,6 +303,13 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
                 new_status[self._key_target_temperature] = temperature
             await self.async_set_attributes(new_status)
 
+    async def async_set_humidity(self, humidity: int):
+        if self._key_target_humidity is None:
+            return
+        new_status = {}
+        new_status[self._key_target_humidity] = int(humidity)
+        await self.async_set_attributes(new_status)
+
     async def async_set_fan_mode(self, fan_mode: str):
         if self._is_central_ac:
             fan_speed = self._key_fan_modes.get(fan_mode)

custom_components/midea_auto_cloud/core/cloud.py

@@ -63,7 +63,7 @@ class MideaCloud:
     def _make_general_data(self):
         return {}
 
-    async def _api_request(self, endpoint: str, data: dict, header=None) -> dict | None:
+    async def _api_request(self, endpoint: str, data: dict, header=None, method="POST") -> dict | None:
         header = header or {}
         if not data.get("reqId"):
             data.update({
@@ -91,15 +91,18 @@ class MideaCloud:
         _LOGGER.debug(f"Midea cloud API header: {header}")
         _LOGGER.debug(f"Midea cloud API dump_data: {dump_data}")
         try:
-            r = await self._session.request("POST", url, headers=header, data=dump_data, timeout=5)
+            r = await self._session.request(method, url, headers=header, data=dump_data, timeout=5)
             raw = await r.read()
             _LOGGER.debug(f"Midea cloud API url: {url}, data: {data}, response: {raw}")
             response = json.loads(raw)
         except Exception as e:
             _LOGGER.debug(f"API request attempt failed: {e}")
 
-        if int(response["code"]) == 0 and "data" in response:
-            return response["data"]
+        if int(response["code"]) == 0:
+            if "data" in response:
+                return response["data"]
+            else:
+                return {"message": "ok"}
 
         return None
 
@@ -207,6 +210,10 @@ class MideaCloud:
         """Get status of central AC devices. Subclasses should implement if supported."""
         raise NotImplementedError()
 
+    async def send_switch_control(self, device_id: str, nodeid: str, switch_control: dict) -> bool:
+        """Send control to switch device. Subclasses should implement if supported."""
+        raise NotImplementedError()
+
 
 class MeijuCloud(MideaCloud):
     APP_ID = "900"
@@ -405,6 +412,39 @@ class MeijuCloud(MideaCloud):
         )
         return response
 
+    async def send_switch_control(self, device_id: str, nodeid: str, switch_control: dict) -> bool:
+        """Send control to switch device using the controlPanelFour API with PUT method."""
+        import uuid
+        
+        # switch_control 格式: {"endPoint": 1, "attribute": 0}
+        end_point = switch_control.get("endPoint", 1)
+        attribute = switch_control.get("attribute", 0)
+        
+        # 构建请求数据
+        request_data = {
+            "msgId": str(uuid.uuid4()).replace("-", ""),
+            "deviceControlList": [{
+                "endPoint": end_point,
+                "attribute": attribute
+            }],
+            "deviceId": device_id,
+            "nodeId": nodeid
+        }
+        
+        MideaLogger.debug(f"Sending switch control to device {device_id}: {request_data}")
+        
+        # 使用PUT方法发送到开关控制API
+        if response := await self._api_request(
+            endpoint="/v1/appliance/operation/controlPanelFour/" + device_id,
+            data=request_data,
+            method="PUT"
+        ):
+            MideaLogger.debug(f"[{device_id}] Switch control response: {response}")
+            return True
+        else:
+            MideaLogger.warning(f"[{device_id}] Switch control failed: {response}")
+            return False
+
     async def download_lua(
             self, path: str,
             device_type: int,

custom_components/midea_auto_cloud/data_coordinator.py

@@ -123,9 +123,7 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
                     for appliance in status_data["appliances"]:
                         if appliance.get("type") == "0x21" and "extraData" in appliance:
                             extra_data = appliance["extraData"]
-                            if "attr" in extra_data and "state" in extra_data["attr"]:
-                                state = extra_data["attr"]["state"]
-
+                            if "attr" in extra_data:
                                 if "nodeid" in extra_data["attr"]:
                                     self.device._attributes["nodeid"] = extra_data["attr"]["nodeid"]
                                 if "masterId" in extra_data["attr"]:
@@ -135,7 +133,8 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
                                 if "idType" in extra_data["attr"]:
                                     self.device._attributes["idType"] = extra_data["attr"]["idType"]
 
-                                if "condition_attribute" in state:
+                                if "state" in extra_data["attr"] and "condition_attribute" in extra_data["attr"]["state"]:
+                                    state = extra_data["attr"]["state"]
                                     condition = state["condition_attribute"]
                                     # 将状态数据更新到设备属性中
                                     for key, value in condition.items():
@@ -153,6 +152,32 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
                                                 self.device._attributes[key] = value
                                         else:
                                             self.device._attributes[key] = value
+
+                                if "endlist" in extra_data["attr"]:
+                                    endlist = extra_data["attr"]["endlist"]
+                                    # endlist是一个数组，包含多个endpoint对象
+                                    if isinstance(endlist, list):
+                                        for endpoint in endlist:
+                                            if "event" in endpoint:
+                                                event = endpoint["event"]
+                                                endpoint_id = endpoint.get("endpoint", 1)
+                                                endpoint_name = endpoint.get("name", f"按键{endpoint_id}")
+                                                
+                                                # 为每个endpoint创建独立的状态属性
+                                                for key, value in event.items():
+                                                    # 创建带endpoint标识的属性名
+                                                    attr_key = f"endpoint_{endpoint_id}_{key}"
+                                                    attr_name_key = f"endpoint_{endpoint_id}_name"
+                                                    
+                                                    # 保存endpoint名称
+                                                    self.device._attributes[attr_name_key] = endpoint_name
+                                                    self.device._attributes[attr_key] = value
+                                                
+                                                # 同时保持原有的属性名（用于兼容性）
+                                                for key, value in event.items():
+                                                    # 尝试将数字字符串转换为数字
+                                                    self.device._attributes[key] = value
+
                                 break
         except Exception as e:
             MideaLogger.debug(f"Error polling central AC state: {e}")
@@ -223,6 +248,78 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
             MideaLogger.debug(f"Error sending control to {self.device.device_name}: {e}")
             return False
 
+    async def async_send_switch_control(self, control: dict) -> bool:
+        """发送开关控制命令（subtype为00000000的设备）"""
+        try:
+            cloud = self._cloud
+            if cloud and hasattr(cloud, "send_switch_control"):
+                # 获取设备ID和nodeId
+                masterid = str(self.device.attributes.get("masterId"))
+                nodeid = str(self.device.attributes.get("nodeid"))
+                
+                if not nodeid:
+                    MideaLogger.warning(f"No nodeid found for switch device {self._device_id}")
+                    return False
+                
+                # 根据控制命令确定endPoint和attribute值
+                end_point = control.get("endpoint", 1)  # 从control中获取endpoint，默认1
+                attribute = 0  # 默认attribute
+                
+                # 根据control内容设置attribute值
+                if "run_mode" in control:
+                    if control["run_mode"] == "1":
+                        attribute = 1  # 开启
+                    else:
+                        attribute = 0  # 关闭
+                
+                # 构建控制数据
+                switch_control = {
+                    "endPoint": end_point,
+                    "attribute": attribute
+                }
+                
+                MideaLogger.debug(f"Sending switch control to {self.device.device_name}: {switch_control}")
+                success = await cloud.send_switch_control(masterid, nodeid, switch_control)
+                
+                if success:
+                    # 更新本地状态 - 使用类似poll_central的解析方法
+                    await self._update_switch_status_from_control(control)
+                    self.mute_state_update_for_a_while()
+                    self.async_update_listeners()
+                    return True
+                else:
+                    MideaLogger.debug(f"Failed to send switch control to {self.device.device_name}")
+                    return False
+            else:
+                MideaLogger.debug("Cloud service not available for switch control")
+                return False
+        except Exception as e:
+            MideaLogger.debug(f"Error sending switch control to {self.device.device_name}: {e}")
+            return False
+
+    async def _update_switch_status_from_control(self, control: dict) -> None:
+        """根据控制命令更新开关状态，参照poll_central的解析方法"""
+        try:
+            # 获取endpoint ID
+            endpoint_id = control.get("endpoint", 1)
+            run_mode = control.get("run_mode", "0")
+            
+            # 模拟endlist数据结构来更新状态
+            # 根据run_mode设置OnOff状态
+            onoff_value = "1" if run_mode == "1" else "0"
+            
+            # 更新endpoint特定的状态属性
+            attr_key = f"endpoint_{endpoint_id}_OnOff"
+            self.device._attributes[attr_key] = onoff_value
+            
+            # 同时更新兼容性属性
+            self.device._attributes["OnOff"] = onoff_value
+            
+            MideaLogger.debug(f"Updated switch status for endpoint {endpoint_id}: OnOff={onoff_value}")
+            
+        except Exception as e:
+            MideaLogger.debug(f"Error updating switch status from control: {e}")
+
     def _build_full_central_ac_control(self, new_control: dict) -> dict:
         """构建完整控制命令"""
         full_control = {}

custom_components/midea_auto_cloud/device_mapping/T0x13.py

@@ -45,7 +45,7 @@ DEVICE_MAPPING = {
             Platform.FAN: {
                 "fan": {
                     "power": "fan_power",
-                    "fan_speed": [
+                    "speeds": [
                         {"fan_speed": "1"},
                         {"fan_speed": "2"},
                         {"fan_speed": "3"},

custom_components/midea_auto_cloud/device_mapping/T0x21.py

@@ -3,6 +3,23 @@ from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass
 from homeassistant.components.switch import SwitchDeviceClass
 
 DEVICE_MAPPING = {
+    "00000000": {
+        "rationale": ["0", "1"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.SWITCH: {
+                "endpoint_1_OnOff": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['0', '1']
+                },
+                "endpoint_2_OnOff": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['0', '1']
+                }
+            },
+        }
+    },
     "default": {
         "rationale": ["off", "on"],
         "queries": [{}],

custom_components/midea_auto_cloud/device_mapping/T0x3D.py

@@ -0,0 +1,48 @@
+from homeassistant.const import Platform, UnitOfTemperature, UnitOfVolume, UnitOfTime, PERCENTAGE, PRECISION_HALVES, \
+    UnitOfEnergy, UnitOfPower, PRECISION_WHOLE
+from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass
+from homeassistant.components.binary_sensor import BinarySensorDeviceClass
+from homeassistant.components.switch import SwitchDeviceClass
+
+DEVICE_MAPPING = {
+    "default": {
+        "rationale": ["off", "on"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.SWITCH: {
+                "work_switch": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['cancel', 'work']
+                }
+            },
+            Platform.SELECT: {
+                "warm_target_temp": {
+                    "options": {
+                        "45℃": {"warm_target_temp": "45"},
+                        "55℃": {"warm_target_temp": "55"},
+                        "65℃": {"warm_target_temp": "65"},
+                        "75℃": {"warm_target_temp": "75"},
+                        "85℃": {"warm_target_temp": "85"}
+                    }
+                },
+                "boil_target_temp": {
+                    "options": {
+                        "45℃": {"boil_target_temp": "45"},
+                        "55℃": {"boil_target_temp": "55"},
+                        "65℃": {"boil_target_temp": "65"},
+                        "75℃": {"boil_target_temp": "75"},
+                        "85℃": {"boil_target_temp": "85"}
+                    }
+                }
+            },
+            Platform.SENSOR: {
+                "cur_temp": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT
+                }
+            }
+        }
+    }
+}

custom_components/midea_auto_cloud/device_mapping/T0xAC.py

@@ -1,4 +1,4 @@
-from homeassistant.const import Platform, UnitOfTemperature, PRECISION_HALVES
+from homeassistant.const import Platform, UnitOfTemperature, PRECISION_HALVES, PRECISION_WHOLE
 from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass
 # from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.switch import SwitchDeviceClass
@@ -132,6 +132,32 @@ DEVICE_MAPPING = {
             }
         }
     },
+    "106J6363": {
+        "rationale": ["off", "on"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.CLIMATE: {
+                "thermostat": {
+                    "power": "water_model_power",
+                    "hvac_modes": {
+                        "off": {"water_model_power": "off"},
+                        "heat": {"water_model_power": "on", "water_model_temperature_auto": "off"},
+                        "auto": {"water_model_power": "on", "water_model_temperature_auto": "on"},
+                    },
+                    "preset_modes": {
+                        "none": {"water_model_go_out": "off"},
+                        "go out": {"water_model_go_out": "on"},
+                    },
+                    "target_temperature": "water_model_temperature_set",
+                    "min_temp": 25,
+                    "max_temp": 60,
+                    "temperature_unit": UnitOfTemperature.CELSIUS,
+                    "precision": PRECISION_WHOLE,
+                }
+            },
+        }
+    },
     "26093139": {
         "rationale": [0, 3],
         "queries": [{}, {"query_type": "run_status"}],
@@ -267,5 +293,86 @@ DEVICE_MAPPING = {
                 },
             }
         }
+    },
+    # Colmo Turing Central AC indoor units, different cooling capacity models share the same config.
+    ("22396961", "22396963", "22396965", "22396969", "22396973"): {
+        "rationale": ["off", "on"],
+        "queries": [{}, {"query_type":"run_status"}],
+        "centralized": [],
+        "entities": {
+            Platform.CLIMATE: {
+                "thermostat": {
+                    "translation_key": "colmo_turing_central_ac_climate",
+                    "power": "power",
+                    "hvac_modes": {
+                        "off": {"power": "off"},
+                        "heat": {"power": "on", "mode": "heat"},
+                        "cool": {"power": "on", "mode": "cool"},
+                        "fan_only": {"power": "on", "mode": "fan"},
+                        "dry": {"power": "on", "mode": "dryauto"},
+                        "auto": {"power": "on", "mode": "dryconstant"},
+                        # Note:
+                        # For Colmo Turing AC, dry and auto mode is not displayed in the app/controller explicitly.
+                        # Instead it defined 2 custom modes: dryauto (自动抽湿) and dryconstant (温湿灵控/恒温恒湿).
+                        # So I mapped the custom modes to the similar pre-defineds:
+                        #   - auto -> dryconstant (温湿灵控/恒温恒湿): able to set target T and H, and auto adjust them to maintain a comfortable environment.
+                        #   - dry -> dryauto (自动抽湿): dehumidification mode, under which temperature is not adjustable.
+                        # Translations are also modified (for only colmo_turing_central_ac_climate) accordingly.
+                    },
+                    "preset_modes": {
+                        "none": {
+                            "energy_save": "off",
+                        },
+                        "sleep": {"energy_save": "on"}
+                    },
+                    "fan_modes": {
+                        "silent": {"wind_speed": 20},
+                        "low": {"wind_speed": 40},
+                        "medium": {"wind_speed": 60},
+                        "high": {"wind_speed": 80},
+                        "full": {"wind_speed": 100},
+                        "auto": {"wind_speed": 102}
+                    },
+                    "target_temperature": ["temperature", "small_temperature"],
+                    "current_temperature": "indoor_temperature",
+                    "target_humidity": "dehumidity",
+                    "current_humidity": "indoor_humidity",
+                    "pre_mode": "mode",
+                    "aux_heat": "ptc",
+                    "min_temp": 16,
+                    "max_temp": 30,
+                    "min_humidity": 45,
+                    "max_humidity": 65,
+                    "temperature_unit": UnitOfTemperature.CELSIUS,
+                    "precision": PRECISION_HALVES,
+                }
+            },
+            Platform.SENSOR: {
+                "mode": {
+                    "device_class": SensorDeviceClass.ENUM,
+                },
+                "indoor_temperature": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT
+                },
+                "indoor_humidity": {
+                    "device_class": SensorDeviceClass.HUMIDITY,
+                    "unit_of_measurement": "%",
+                    "state_class": SensorStateClass.MEASUREMENT
+                },
+                "wind_speed_real": {
+                    "device_class": SensorDeviceClass.WIND_SPEED,
+                    "unit_of_measurement": "%",
+                    "state_class": SensorStateClass.MEASUREMENT
+                }
+            },
+            Platform.SWITCH: {
+                "power": {
+                    "name": "电源",
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+            },
+        }
     }
 }

custom_components/midea_auto_cloud/device_mapping/T0xFA.py

@@ -8,34 +8,38 @@ DEVICE_MAPPING = {
         "rationale": ["off", "on"],
         "queries": [{}],
         "centralized": [
-            "power", "humidify", "swing", "anion", "display_on_off", 
-            "dust_reset", "temp_wind_switch", "filter_reset"
+            "power", "swing", "display_on_off", "temp_wind_switch",
         ],
         "entities": {
-            Platform.BINARY_SENSOR: {
-                "power": {
-                    "device_class": BinarySensorDeviceClass.POWER,
-                },
-                "humidify": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
-                },
-                "swing": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
-                },
-                "anion": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
-                },
+            Platform.SWITCH: {
                 "display_on_off": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
-                },
-                "dust_reset": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ["on", "off"]
                 },
                 "temp_wind_switch": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
+                    "device_class": SwitchDeviceClass.SWITCH,
                 },
-                "filter_reset": {
-                    "device_class": BinarySensorDeviceClass.RUNNING,
+            },
+            Platform.FAN: {
+                "fan": {
+                    "power": "power",
+                    "speeds": [
+                        {"gear": "1"},
+                        {"gear": "2"},
+                        {"gear": "3"},
+                        {"gear": "4"},
+                        {"gear": "5"},
+                        {"gear": "6"},
+                        {"gear": "7"},
+                        {"gear": "8"},
+                        {"gear": "9"},
+                    ],
+                    "oscillate": "swing",
+                    "preset_modes": {
+                        "normal": {"mode": "normal"},
+                        "sleep": {"mode": "sleep"},
+                        "baby": {"mode": "baby"}
+                    }
                 }
             },
             Platform.SELECT: {
@@ -65,16 +69,6 @@ DEVICE_MAPPING = {
                         "both": {"swing_direction": "both"}
                     }
                 },
-                "scene": {
-                    "options": {
-                        "none": {"scene": "none"},
-                        "auto": {"scene": "auto"},
-                        "sleep": {"scene": "sleep"},
-                        "work": {"scene": "work"},
-                        "study": {"scene": "study"},
-                        "party": {"scene": "party"}
-                    }
-                },
                 "sleep_sensor": {
                     "options": {
                         "none": {"sleep_sensor": "none"},
@@ -83,27 +77,6 @@ DEVICE_MAPPING = {
                         "both": {"sleep_sensor": "both"}
                     }
                 },
-                "mode": {
-                    "options": {
-                        "normal": {"mode": "normal"},
-                        "auto": {"mode": "auto"},
-                        "manual": {"mode": "manual"},
-                        "sleep": {"mode": "sleep"},
-                        "turbo": {"mode": "turbo"},
-                        "quiet": {"mode": "quiet"}
-                    }
-                },
-                "gear": {
-                    "options": {
-                        "1": {"gear": "1"},
-                        "2": {"gear": "2"},
-                        "3": {"gear": "3"},
-                        "4": {"gear": "4"},
-                        "5": {"gear": "5"},
-                        "6": {"gear": "6"},
-                        "auto": {"gear": "auto"}
-                    }
-                }
             },
             Platform.SENSOR: {
                 "real_gear": {
@@ -120,19 +93,6 @@ DEVICE_MAPPING = {
                     "unit_of_measurement": UnitOfTime.HOURS,
                     "state_class": SensorStateClass.MEASUREMENT
                 },
-                "battery_status": {
-                    "device_class": SensorDeviceClass.BATTERY,
-                    "state_class": SensorStateClass.MEASUREMENT
-                },
-                "battery_level": {
-                    "device_class": SensorDeviceClass.BATTERY,
-                    "unit_of_measurement": PERCENTAGE,
-                    "state_class": SensorStateClass.MEASUREMENT
-                },
-                "error_code": {
-                    "device_class": SensorDeviceClass.ENUM,
-                    "state_class": SensorStateClass.MEASUREMENT
-                },
                 "temperature_feedback": {
                     "device_class": SensorDeviceClass.TEMPERATURE,
                     "unit_of_measurement": UnitOfTemperature.CELSIUS,
@@ -162,10 +122,6 @@ DEVICE_MAPPING = {
                     "unit_of_measurement": UnitOfTime.MINUTES,
                     "state_class": SensorStateClass.MEASUREMENT
                 },
-                "version": {
-                    "device_class": SensorDeviceClass.ENUM,
-                    "state_class": SensorStateClass.MEASUREMENT
-                },
                 "pm25": {
                     "device_class": SensorDeviceClass.PM25,
                     "unit_of_measurement": "µg/m³",
@@ -176,22 +132,22 @@ DEVICE_MAPPING = {
                     "state_class": SensorStateClass.MEASUREMENT
                 },
                 "lr_diy_down_percent": {
-                    "device_class": SensorDeviceClass.ENUM,
+                    "device_class": SensorDeviceClass.BATTERY,
                     "unit_of_measurement": PERCENTAGE,
                     "state_class": SensorStateClass.MEASUREMENT
                 },
                 "lr_diy_up_percent": {
-                    "device_class": SensorDeviceClass.ENUM,
+                    "device_class": SensorDeviceClass.BATTERY,
                     "unit_of_measurement": PERCENTAGE,
                     "state_class": SensorStateClass.MEASUREMENT
                 },
                 "ud_diy_down_percent": {
-                    "device_class": SensorDeviceClass.ENUM,
+                    "device_class": SensorDeviceClass.BATTERY,
                     "unit_of_measurement": PERCENTAGE,
                     "state_class": SensorStateClass.MEASUREMENT
                 },
                 "ud_diy_up_percent": {
-                    "device_class": SensorDeviceClass.ENUM,
+                    "device_class": SensorDeviceClass.BATTERY,
                     "unit_of_measurement": PERCENTAGE,
                     "state_class": SensorStateClass.MEASUREMENT
                 }

custom_components/midea_auto_cloud/device_mapping/T0xFB.py

@@ -0,0 +1,53 @@
+from homeassistant.const import Platform, UnitOfTemperature, UnitOfVolume, UnitOfTime, PERCENTAGE, PRECISION_HALVES, \
+    UnitOfEnergy, UnitOfPower
+from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass
+from homeassistant.components.binary_sensor import BinarySensorDeviceClass
+from homeassistant.components.switch import SwitchDeviceClass
+
+DEVICE_MAPPING = {
+    "default": {
+        "rationale": ["off", "on"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.SWITCH: {
+                "lock": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "screen_close": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                }
+            },
+            Platform.CLIMATE: {
+                "electric_heater": {
+                    "power": "power",
+                    "hvac_modes": {
+                        "off": {"power": "off"},
+                        "heat": {"power": "on"}
+                    },
+                    "target_temperature": "temperature",
+                    "current_temperature": "cur_temperature",
+                    "min_temp": 5,
+                    "max_temp": 35,
+                    "temperature_unit": UnitOfTemperature.CELSIUS,
+                    "precision": PRECISION_HALVES,
+                }
+            },
+            Platform.SELECT: {
+                "gear": {
+                    "options": {
+                        "low": {"gear": 1},
+                        "high": {"gear": 3}
+                    }
+                }
+            },
+            Platform.SENSOR: {
+                "power_statistics": {
+                    "device_class": SensorDeviceClass.POWER,
+                    "unit_of_measurement": UnitOfPower.WATT,
+                    "state_class": SensorStateClass.MEASUREMENT
+                }
+            }
+        }
+    }
+}

custom_components/midea_auto_cloud/icons.json

@@ -0,0 +1,26 @@
+{
+  "entity": {
+    "climate": {
+      "thermostat": {
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "silent": "mdi:weather-night",
+              "full": "mdi:fan"
+            }
+          }
+        }
+      },
+      "colmo_turing_central_ac_climate": {
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "silent": "mdi:weather-night",
+              "full": "mdi:fan"
+            }
+          }
+        }
+      }
+    }
+  }
+}

custom_components/midea_auto_cloud/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "cloud_push",
   "issue_tracker": "https://github.com/sususweet/midea-meiju-codec/issues",
   "requirements": ["lupa>=2.0"],
-  "version": "v0.1.10"
+  "version": "v0.1.14"
 }

custom_components/midea_auto_cloud/switch.py

@@ -5,6 +5,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DOMAIN
+from .core.logger import MideaLogger
 from .midea_entity import MideaEntity
 from . import load_device_config
 
@@ -43,6 +44,9 @@ class MideaSwitchEntity(MideaEntity, SwitchEntity):
     """Midea switch entity."""
 
     def __init__(self, coordinator, device, manufacturer, rationale, entity_key, config):
+        # 自动判断是否为中央空调设备（T0x21）
+        self._is_central_ac = device.device_type == 0x21
+        
         super().__init__(
             coordinator,
             device.device_id,
@@ -67,12 +71,37 @@ class MideaSwitchEntity(MideaEntity, SwitchEntity):
 
     async def async_turn_on(self):
         """Turn the switch on."""
-        # Use attribute from config if available, otherwise fall back to entity_key
         attribute = self._config.get("attribute", self._entity_key)
-        await self._async_set_status_on_off(attribute, True)
+        if self._is_central_ac:
+            await self._async_set_central_ac_switch_status(True)
+        else:
+            await self._async_set_status_on_off(attribute, True)
 
     async def async_turn_off(self):
         """Turn the switch off."""
-        # Use attribute from config if available, otherwise fall back to entity_key
         attribute = self._config.get("attribute", self._entity_key)
-        await self._async_set_status_on_off(attribute, False)
+        if self._is_central_ac:
+            await self._async_set_central_ac_switch_status(False)
+        else:
+            await self._async_set_status_on_off(attribute, False)
+
+    async def _async_set_central_ac_switch_status(self, is_on: bool):
+        """设置中央空调开关设备的状态"""
+        # 从entity_key中提取endpoint ID
+        # entity_key格式: endpoint_1_OnOff -> 提取出 1
+        endpoint_id = 1  # 默认值
+        if self._entity_key.startswith("endpoint_"):
+            try:
+                # 提取endpoint_后面的数字
+                parts = self._entity_key.split("_")
+                if len(parts) >= 2:
+                    endpoint_id = int(parts[1])
+            except (ValueError, IndexError):
+                MideaLogger.warning(f"Failed to extract endpoint ID from {self._entity_key}, using default 1")
+        
+        # 构建控制命令
+        control = {
+            "run_mode": "1" if is_on else "0",
+            "endpoint": endpoint_id
+        }
+        await self.coordinator.async_send_switch_control(control)

custom_components/midea_auto_cloud/translations/en.json

@@ -291,30 +291,6 @@
       "execute": {
         "name": "Execute"
       },
-      "power": {
-        "name": "Power"
-      },
-      "humidify": {
-        "name": "Humidify"
-      },
-      "swing": {
-        "name": "Swing"
-      },
-      "anion": {
-        "name": "Anion"
-      },
-      "display_on_off": {
-        "name": "Display On/Off"
-      },
-      "dust_reset": {
-        "name": "Dust Reset"
-      },
-      "temp_wind_switch": {
-        "name": "Temp Wind Switch"
-      },
-      "filter_reset": {
-        "name": "Filter Reset"
-      },
       "heat_status": {
         "name": "Heat Status"
       },
@@ -336,10 +312,32 @@
         "name": "Storage Zone"
       },
       "thermostat": {
-        "name": "Thermostat"
+        "name": "Thermostat",
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "silent": "Silent",
+              "full": "Full"
+            }
+          }
+        }
+      },
+      "colmo_turing_central_ac_climate": {
+        "name": "Thermostat",
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "silent": "Silent",
+              "full": "Full"
+            }
+          }
+        }
       },
       "water_heater": {
         "name": "Water Heater"
+      },
+      "electric_heater": {
+        "name": "Electric Heater"
       }
     },
     "humidifier": {
@@ -351,6 +349,12 @@
       }
     },
     "select": {
+      "warm_target_temp": {
+        "name": "Warm Target Temperature"
+      },
+      "boil_target_temp": {
+        "name": "Boil Target Temperature"
+      },
       "add_rinse": {
         "name": "Add Rinse"
       },
@@ -1511,6 +1515,12 @@
       }
     },
     "switch": {
+      "temp_wind_switch": {
+        "name": "Wind Change with Temperature"
+      },
+      "screen_close": {
+        "name": "Screen Close"
+      },
       "anion": {
         "name": "Anion"
       },
@@ -2362,6 +2372,33 @@
       },
       "is_lock_rc": {
         "name": "Remote Control Lock"
+      },
+      "endpoint_1_onoff": {
+        "name": "Button 1"
+      },
+      "endpoint_2_onoff": {
+        "name": "Button 2"
+      },
+      "endpoint_3_onoff": {
+        "name": "Button 3"
+      },
+      "endpoint_4_onoff": {
+        "name": "Button 4"
+      },
+      "endpoint_5_onoff": {
+        "name": "Button 5"
+      },
+      "endpoint_6_onoff": {
+        "name": "Button 6"
+      },
+      "endpoint_7_onoff": {
+        "name": "Button 7"
+      },
+      "endpoint_8_onoff": {
+        "name": "Button 8"
+      },
+      "work_switch": {
+        "name": "Work Switch"
       }
     }
   }

custom_components/midea_auto_cloud/translations/zh-Hans.json

@@ -291,30 +291,6 @@
       "execute": {
         "name": "执行"
       },
-      "power": {
-        "name": "电源"
-      },
-      "humidify": {
-        "name": "加湿"
-      },
-      "swing": {
-        "name": "摆风"
-      },
-      "anion": {
-        "name": "负离子"
-      },
-      "display_on_off": {
-        "name": "显示开关"
-      },
-      "dust_reset": {
-        "name": "灰尘重置"
-      },
-      "temp_wind_switch": {
-        "name": "温风开关"
-      },
-      "filter_reset": {
-        "name": "滤网重置"
-      },
       "heat_status": {
         "name": "加热状态"
       },
@@ -336,10 +312,36 @@
         "name": "冷藏区"
       },
       "thermostat": {
-        "name": "温控器"
+        "name": "温控器",
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "silent": "静音",
+              "full": "强劲"
+            }
+          }
+        }
+      },
+      "colmo_turing_central_ac_climate": {
+        "name": "温控器",
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "silent": "静音",
+              "full": "强劲"
+            }
+          }
+        },
+        "state": {
+          "auto": "温湿灵控",
+          "dry": "自动抽湿"
+        }
       },
       "water_heater": {
         "name": "热水器"
+      },
+      "electric_heater": {
+        "name": "取暖器"
       }
     },
     "humidifier": {
@@ -351,6 +353,12 @@
       }
     },
     "select": {
+      "warm_target_temp": {
+        "name": "保温目标温度"
+      },
+      "boil_target_temp": {
+        "name": "煮沸目标温度"
+      },
       "add_rinse": {
         "name": "加漂洗"
       },
@@ -1511,6 +1519,12 @@
       }
     },
     "switch": {
+      "temp_wind_switch": {
+        "name": "风随温变"
+      },
+      "screen_close": {
+        "name": "屏幕关闭"
+      },
       "anion": {
         "name": "负离子"
       },
@@ -2362,6 +2376,33 @@
       },
       "is_lock_rc": {
         "name": "遥控锁定"
+      },
+      "endpoint_1_onoff": {
+        "name": "按键一"
+      },
+      "endpoint_2_onoff": {
+        "name": "按键二"
+      },
+      "endpoint_3_onoff": {
+        "name": "按键三"
+      },
+      "endpoint_4_onoff": {
+        "name": "按键四"
+      },
+      "endpoint_5_onoff": {
+        "name": "按键五"
+      },
+      "endpoint_6_onoff": {
+        "name": "按键六"
+      },
+      "endpoint_7_onoff": {
+        "name": "按键七"
+      },
+      "endpoint_8_onoff": {
+        "name": "按键八"
+      },
+      "work_switch": {
+        "name": "工作开关"
       }
     }
   }