feat: version v0.1.14

feat: add support for T0xFA.
Merge remote-tracking branch 'origin/master'
2025-11-12 16:01:54 +00:00 · 2025-10-28 22:47:39 +08:00 · 2025-10-28 22:44:58 +08:00 · 2025-10-28 22:04:45 +08:00 · 2025-10-28 22:04:27 +08:00 · 2025-10-28 16:16:40 +08:00
32 changed files with 1792 additions and 324 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -153,6 +153,7 @@ cython_debug/

 .idea

+decrypt_lua.py
 test.py
 *.lua

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,123 @@
+# 贡献指南
+
+感谢您考虑为我们的项目做出贡献！您的努力将使我们的项目变得更好。
+
+在您开始贡献之前，请花一点时间阅读以下准则：
+
+## 我可以如何贡献？
+
+### 报告问题
+
+如果您在项目中遇到错误，请在 GitHub 上[报告问题](https://github.com/sususweet/midea_auto_cloud/issues/new/)，并提供关于错误的详细信息，包括复现步骤、 debug 级日志以及错误出现的时间。
+
+集成开启 debug 级日志的[方法](https://www.home-assistant.io/integrations/logger/#log-filters)：
+
+```
+# configuration.yaml 设置打印日志等级
+
+logger:
+  default: critical
+  logs:
+    custom_components.xiaomi_home: debug
+```
+
+### 建议增强功能
+
+如果您有增强或新功能的想法，欢迎您在 GitHub 讨论区[创建想法](https://github.com/sususweet/midea_auto_cloud/discussions/new?category=ideas) 。我们期待您的建议！
+
+### 贡献代码
+
+1. Fork 该仓库并从 `master` 创建您的分支。
+2. 确保您的代码符合项目的编码规范。
+3. 确保您的提交消息描述清晰。
+4. 提交请求应附有明确的问题描述和解决方案。
+5. 如果必要，请更新文档。
+6. 请运行测试并确保测试通过。
+
+## 适配设备
+
+要适配本项目中暂未包含的设备，可以按照以下步骤进行：
+
+1. 在Homeassistant中安装本插件，安装完成后登录自己的账号，可以看到自己名下的设备。
+
+2. 在集成中找到需要适配的设备，点击设备的相关字段进入详情页面，如下图：
+
+![img_2.png](./img/img_2.png)
+
+3. 点击传感器中的`连通性`，可以看到该设备可以被读取和访问的状态，如下图：  
+
+![img_3.png](./img/img_3.png)
+
+着重关注Device type、Subtype这两个字段，这是后续获得设备控制对应lua文件的基础。
+
+4. 进入Homeassistant的安装目录，在`.storage/midea_auto_cloud/lua/`目录下找到T_0000_`Device type`_`Subtype`_***.lua文件，例如上面干衣机设备的lua文件是： T_0000_DC_12852_2021121701.lua。
+
+5. 可用人工分析或者AI分析的方法解析lua文件，结合美的官方APP的控制界面，提取出需要控制的设备属性，把修改合并到`device_mapping`中对应设备`Device type`的py文件中。
+
+6. `device_mapping`中设备映射文件的编写方法可参考之前编写过的，`default`是默认的映射，可以作为参考，默认改这个就可以。如果自己设备的映射跟通用的差别太大（目前发现有空调、新风系统设备类型都是T0xAC，但可控制的变量差别比较大），可以根据设备的sn8来新建字段。
+
+7. 完成上述步骤，编写好`device_mapping`中对应设备的py文件，即可在自己的机器上测试，测试好后就可以提pr。
+
+## 拉取请求准则
+
+在提交拉取请求之前，请确保满足以下要求：
+
+- 您的拉取请求解决了单个问题或功能。
+- 您已在本地测试过您的更改。
+- 您的代码遵循项目的代码规范。
+- 所有现有测试都通过，并且如果适用，您已添加了新的测试。
+- 任何依赖更改都有文档说明。
+
+## 代码规范
+
+本项目的代码格式遵循 [Google Style](https://google.github.io/styleguide/pyguide.html) 。请确保您的贡献符合该指南。
+
+## Commit Message 格式
+
+```
+<type>: <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+```
+
+type ：有以下几种变更类型
+
+- feat：新增功能。
+- fix：修复问题。
+- docs：仅仅修改了文档。
+- style：仅仅是对格式进行修改，如逗号、缩进、空格等，不改变代码逻辑。
+- refactor：代码重构，没有新增功能或修复问题。
+- perf：优化性能。
+- test：增加或修改测试用例。
+- chore：修改编译流程，或变更依赖库和工具等。
+- revert：版本回滚。
+
+subject ：简洁的标题，描述本次提交的概要。使用祈使句、现在时态，首字母小写，结尾不加句号。
+
+body ：描述本次提交的详细内容，解释为什么需要这些变更。除 docs 之外的变更类型必须包含 body。
+
+footer ：（可选）关联的 issue 或 pull request 编号。
+
+## 命名规范
+
+### 第三方平台命名规范
+
+- 描述“Home Assistant”时必须使用“Home Assistant”，变量可以使用“hass”或“hass_xxx”。
+
+### 其它命名规范
+
+- 文档中的中文语句包含英文时，如果英文没有被中文引号括起来，那么中文与英文之间必须有一个空格。（最好代码注释也这么写）
+
+## 许可
+
+在为本项目做出贡献时，您同意您的贡献遵循本项目的[许可证](../LICENSE.md) 。
+
+当您第一次提交拉取请求时，GitHub Action 会提示您签署贡献者许可协议（Contributor License Agreement，CLA）。只有签署了 CLA ，本项目才会合入您的拉取请求。
+
+## 获取帮助
+
+如果您需要帮助或有疑问，可在 GitHub 的[讨论区](https://github.com/sususweet/midea_auto_cloud/discussions/)询问。
+
+您还可以联系 sususweetcandy@qq.com
--- a/README.md
+++ b/README.md
@@ -1,55 +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.

- 所有设备默认可生成一个名为Status的二进制传感器，其属性中列出了设备可访问的所有属性，当然有些值不可设置
- Status实体前几项列出了该设备的分类信息，供参考
+- Automatically discover and find devices
+- Automatically download device protocol files
+- Update device status to visible device attributes

-## 目前支持的设备类型
+## Version Notes

- T0x26 浴霸
- T0xA1 除湿机
- T0xAC 空调
- T0xB2 电蒸箱
- T0xB3 消毒碗柜
- T0xB7 燃气灶
- T0xB8 智能扫地机器人
- T0xCA 对开门冰箱
- T0xCC 中央空调(风管机)Wi-Fi线控器
- T0xCE 新风机
- T0xCF 中央空调暖家
- T0xD9 复式洗衣机
- T0xDB 滚筒洗衣机
- T0xDC 干衣机
- T0xE1 洗碗机
- T0xE2 电热水器
- T0xE3 恒温式燃气热水器
- T0xEA 电饭锅
- T0xED 软水机
- T0xFA 电风扇
- T0xFD 加湿器
+- 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

-欢迎合作开发添加更多设备支持。
+## 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

-![img.png](img.png)
+Welcome to collaborate on adding support for more devices.

-展开下面的`属性`卡片，把里面这些字段复制给我或随issue提交，等待适配就可以了。
+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_1.png](img_1.png)
+![img.png](./img/img.png)

-## 实体映射
+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.

-映射文件位于`device_mapping`下, 每个大的品类一个映射文件，目前支持映射的实体类型如下:
+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
+
+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
@@ -58,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.
--- a/README_zh_CN.md
+++ b/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)项目提供的先验知识。
--- a/custom_components/midea_auto_cloud/init.py
+++ b/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

@@ -55,6 +56,7 @@ PLATFORMS: list[Platform] = [
    Platform.SELECT,
    Platform.WATER_HEATER,
    Platform.FAN,
+    Platform.LIGHT,
    Platform.HUMIDIFIER
 ]

@@ -95,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
--- a/custom_components/midea_auto_cloud/climate.py
+++ b/custom_components/midea_auto_cloud/climate.py
@@ -51,6 +51,9 @@ async def async_setup_entry(

 class MideaClimateEntity(MideaEntity, ClimateEntity):
    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,
@@ -76,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")

@@ -86,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:
@@ -108,23 +117,53 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):

    @property
    def target_temperature(self):
-        if isinstance(self._key_target_temperature, list):
-            temp_int = self._get_nested_value(self._key_target_temperature[0])
-            tem_dec = self._get_nested_value(self._key_target_temperature[1])
-            if temp_int is not None and tem_dec is not None:
-                try:
-                    return float(temp_int) + float(tem_dec)
-                except (ValueError, TypeError):
-                    return None
+        if self._is_central_ac:
+            run_mode = self._get_nested_value(self._key_power) or "0"
+            if run_mode == "2":  # 制冷模式
+                return self._get_nested_value("cool_temp_set")
+            elif run_mode == "3":  # 制热模式
+                return self._get_nested_value("cool_temp_set")
            return None
        else:
-            temp = self._get_nested_value(self._key_target_temperature)
-            if temp is not None:
-                try:
-                    return float(temp)
-                except (ValueError, TypeError):
-                    return None
-            return None
+            if isinstance(self._key_target_temperature, list):
+                temp_int = self._get_nested_value(self._key_target_temperature[0])
+                tem_dec = self._get_nested_value(self._key_target_temperature[1])
+                if temp_int is not None and tem_dec is not None:
+                    try:
+                        return float(temp_int) + float(tem_dec)
+                    except (ValueError, TypeError):
+                        return None
+                return None
+            else:
+                temp = self._get_nested_value(self._key_target_temperature)
+                if temp is not None:
+                    try:
+                        return float(temp)
+                    except (ValueError, TypeError):
+                        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):
@@ -140,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
@@ -148,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())
@@ -166,11 +227,21 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):

    @property
    def swing_modes(self):
-        return list(self._key_swing_modes.keys())
+        if self._is_central_ac:
+            return ["off", "on"]
+        else:
+            return list(self._key_swing_modes.keys())

    @property
    def swing_mode(self):
-        return self._dict_get_selected(self._key_swing_modes)
+        if self._is_central_ac:
+            extflag = self._get_nested_value("extflag") or "0"
+            # extflag: 4=摇摆, 6=电辅热+摇摆
+            if extflag in ["4", "6"]:
+                return "on"
+            return "off"
+        else:
+            return self._dict_get_selected(self._key_swing_modes)

    @property
    def is_on(self) -> bool:
@@ -204,35 +275,87 @@ class MideaClimateEntity(MideaEntity, ClimateEntity):
        if ATTR_TEMPERATURE not in kwargs:
            return
        temperature = kwargs.get(ATTR_TEMPERATURE)
-        temp_int, temp_dec = divmod(temperature, 1)
-        temp_int = int(temp_int)
-        hvac_mode = kwargs.get(ATTR_HVAC_MODE)
-        if hvac_mode is not None:
-            new_status = self._key_hvac_modes.get(hvac_mode)
+        
+        if self._is_central_ac:
+            run_mode = self._get_nested_value(self._key_power) or "0"
+            control = {}
+            
+            if run_mode == "2":  # 制冷模式
+                control["cooling_temp"] = str(temperature)
+            elif run_mode == "3":  # 制热模式
+                control["cooling_temp"] = str(temperature)
+                control["heating_temp"] = str(temperature)
+            
+            if control:
+                await self.coordinator.async_send_central_ac_control(control)
        else:
-            new_status = {}
-        if isinstance(self._key_target_temperature, list):
-            new_status[self._key_target_temperature[0]] = temp_int
-            new_status[self._key_target_temperature[1]] = temp_dec
-        else:
-            new_status[self._key_target_temperature] = temperature
+            temp_int, temp_dec = divmod(temperature, 1)
+            temp_int = int(temp_int)
+            hvac_mode = kwargs.get(ATTR_HVAC_MODE)
+            if hvac_mode is not None:
+                new_status = self._key_hvac_modes.get(hvac_mode)
+            else:
+                new_status = {}
+            if isinstance(self._key_target_temperature, list):
+                new_status[self._key_target_temperature[0]] = temp_int
+                new_status[self._key_target_temperature[1]] = temp_dec
+            else:
+                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):
-        new_status = self._key_fan_modes.get(fan_mode)
-        await self.async_set_attributes(new_status)
+        if self._is_central_ac:
+            fan_speed = self._key_fan_modes.get(fan_mode)
+            await self.coordinator.async_send_central_ac_control(fan_speed)
+        else:
+            new_status = self._key_fan_modes.get(fan_mode)
+            await self.async_set_attributes(new_status)

    async def async_set_preset_mode(self, preset_mode: str):
-        new_status = self._key_preset_modes.get(preset_mode)
-        await self.async_set_attributes(new_status)
+        if self._is_central_ac:
+            new_status = self._key_preset_modes.get(preset_mode)
+            await self.coordinator.async_send_central_ac_control(new_status)
+        else:
+            new_status = self._key_preset_modes.get(preset_mode)
+            await self.async_set_attributes(new_status)

    async def async_set_hvac_mode(self, hvac_mode: str):
-        new_status = self._key_hvac_modes.get(hvac_mode)
-        await self.async_set_attributes(new_status)
+        if self._is_central_ac:
+            run_mode = self._key_hvac_modes.get(hvac_mode)
+            await self.coordinator.async_send_central_ac_control(run_mode)
+        else:
+            new_status = self._key_hvac_modes.get(hvac_mode)
+            await self.async_set_attributes(new_status)

    async def async_set_swing_mode(self, swing_mode: str):
-        new_status = self._key_swing_modes.get(swing_mode)
-        await self.async_set_attributes(new_status)
+        if self._is_central_ac:
+            current_extflag = self._get_nested_value("extflag") or "0"
+            
+            if swing_mode == "on":
+                # 开启摆风：如果当前有电辅热(2)，则设为6(电辅热+摆风)，否则设为4(摆风)
+                if current_extflag == "2":
+                    new_extflag = "6"  # 电辅热+摆风
+                else:
+                    new_extflag = "4"  # 仅摆风
+            else:
+                # 关闭摆风：如果当前是6(电辅热+摆风)，则设为2(仅电辅热)，否则设为0(关闭)
+                if current_extflag == "6":
+                    new_extflag = "2"  # 仅电辅热
+                else:
+                    new_extflag = "0"  # 关闭
+            
+            control = {"extflag": new_extflag}
+            await self.coordinator.async_send_central_ac_control(control)
+        else:
+            new_status = self._key_swing_modes.get(swing_mode)
+            await self.async_set_attributes(new_status)

    async def async_turn_aux_heat_on(self) -> None:
        await self._async_set_status_on_off(self._key_aux_heat, True)
--- a/custom_components/midea_auto_cloud/core/cloud.py
+++ b/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

@@ -198,6 +201,18 @@ class MideaCloud:
    async def send_device_control(self, appliance_code: int, control: dict, status: dict | None = None) -> bool:
        """Send control to a device via cloud. Subclasses should implement if supported."""
        raise NotImplementedError()
+    
+    async def send_central_ac_control(self, appliance_code: int, nodeid: str, modelid: str, idtype: int, control: dict) -> bool:
+        """Send control to central AC subdevice. Subclasses should implement if supported."""
+        raise NotImplementedError()
+    
+    async def get_central_ac_status(self, appliance_codes: list) -> dict | None:
+        """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):
@@ -223,6 +238,7 @@ class MeijuCloud(MideaCloud):
            password=password,
            api_url=clouds[cloud_name]["api_url"]
        )
+        self._homegroup_id = None

    async def login(self) -> bool:
        if login_id := await self._get_login_id():
@@ -275,6 +291,8 @@ class MeijuCloud(MideaCloud):
        return None

    async def list_appliances(self, home_id) -> dict | None:
+        # 存储当前使用的 homegroupId 用于后续的中央空调控制
+        self._homegroup_id = str(home_id)
        data = {
            "homegroupId": home_id
        }
@@ -304,11 +322,11 @@ class MeijuCloud(MideaCloud):
            return appliances
        return None

-    async def get_device_status(self, appliance_code: int) -> dict | None:
+    async def get_device_status(self, appliance_code: int, query: dict) -> dict | None:
        data = {
            "applianceCode": str(appliance_code),
            "command": {
-                "query": {}
+                "query": query
            }
        }
        if response := await self._api_request(
@@ -333,6 +351,99 @@ class MeijuCloud(MideaCloud):
            data=data
        )
        return response is not None
+    
+    async def send_central_ac_control(self, appliance_code: int, nodeid: str, modelid: str, idtype: int, control: dict) -> bool:
+        """Send control to central AC subdevice using the special T0x21 API."""
+        import uuid
+        import json
+        
+        # 构建中央空调控制命令
+        command_data = {
+            "nodeid": nodeid,
+            "acattri_ctrl": {
+                "aclist": [{
+                    "nodeid": nodeid,
+                    "modelid": modelid,
+                    "type": idtype
+                }],
+                "event": control
+            }
+        }
+        
+        # 构建完整的请求数据
+        request_data = {
+            "applianceCode": str(appliance_code),
+            "modelId": modelid,
+            "topic": "/subdevice/multicontrol",
+            "command": command_data,
+            "msgId": str(uuid.uuid4()).replace("-", "")
+        }
+        request_data_str = json.dumps(request_data).encode("utf-8")
+        MideaLogger.debug(f"Sending control to central AC device {appliance_code}: {request_data_str}")
+        # 发送到特殊的中央空调API
+        if response := await self._api_request(
+            endpoint="/v1/gateway/transport/send",
+            data={
+                'applianceCode': str(appliance_code),
+                'order': self._security.aes_encrypt(request_data_str).hex(),
+                'homegroupId': self._homegroup_id,
+            }
+        ):
+            if response and response.get('reply'):
+                reply_data = self._security.aes_decrypt(bytes.fromhex(response['reply']))
+                MideaLogger.debug(f"[{appliance_code}] Gateway command response: {reply_data}")
+                return reply_data
+            else:
+                MideaLogger.warning(f"[{appliance_code}] Gateway command failed: {response}")
+
+
+    async def get_central_ac_status(self, appliance_codes: list) -> dict | None:
+        """Get status of central AC devices using the aggregator API."""
+
+        # 构建请求数据
+        request_data = {
+            "entities": ["endlist", "tips"],
+            "appliances": [{"id": str(code), "type": "0x21"} for code in appliance_codes],
+        }
+        
+        response = await self._api_request(
+            endpoint="/api/v1/aggregator/appliances",
+            data=request_data
+        )
+        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,
--- a/custom_components/midea_auto_cloud/core/device.py
+++ b/custom_components/midea_auto_cloud/core/device.py
@@ -166,14 +166,15 @@ class MiedaDevice(threading.Thread):
            
            # Convert dot-notation attributes to nested structure for transmission
            nested_status = self._convert_to_nested_structure(new_status)
-            
-            try:
-                if set_cmd := self._lua_runtime.build_control(nested_status, status=self._attributes):
-                    await self._build_send(set_cmd)
-                    return
-            except Exception as e:
-                MideaLogger.debug(f"LuaRuntimeError in set_attribute {nested_status}: {repr(e)}")
-                traceback.print_exc()
+
+            if self._lua_runtime is not None:
+                try:
+                    if set_cmd := self._lua_runtime.build_control(nested_status, status=self._attributes):
+                        await self._build_send(set_cmd)
+                        return
+                except Exception as e:
+                    MideaLogger.debug(f"LuaRuntimeError in set_attribute {nested_status}: {repr(e)}")
+                    traceback.print_exc()

            cloud = self._cloud
            if cloud and hasattr(cloud, "send_device_control"):
@@ -193,13 +194,14 @@ class MiedaDevice(threading.Thread):
        nested_status = self._convert_to_nested_structure(new_status)
        
        if has_new:
-            try:
-                if set_cmd := self._lua_runtime.build_control(nested_status, status=self._attributes):
-                    await self._build_send(set_cmd)
-                    return
-            except Exception as e:
-                    MideaLogger.debug(f"LuaRuntimeError in set_attributes {nested_status}: {repr(e)}")
-                    traceback.print_exc()
+            if self._lua_runtime is not None:
+                try:
+                    if set_cmd := self._lua_runtime.build_control(nested_status, status=self._attributes):
+                        await self._build_send(set_cmd)
+                        return
+                except Exception as e:
+                        MideaLogger.debug(f"LuaRuntimeError in set_attributes {nested_status}: {repr(e)}")
+                        traceback.print_exc()

            cloud = self._cloud
            if cloud and hasattr(cloud, "send_device_control"):
@@ -267,8 +269,9 @@ class MiedaDevice(threading.Thread):

    async def refresh_status(self):
        for query in self._queries:
-            if query_cmd := self._lua_runtime.build_query(query):
-                await self._build_send(query_cmd)
+            if self._lua_runtime is not None:
+                if query_cmd := self._lua_runtime.build_query(query):
+                    await self._build_send(query_cmd)

    def _parse_cloud_message(self, decrypted):
        # MideaLogger.debug(f"Received: {decrypted}")
--- a/custom_components/midea_auto_cloud/data_coordinator.py
+++ b/custom_components/midea_auto_cloud/data_coordinator.py
@@ -90,17 +90,11 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
            return self.data

        try:
-            await self.device.refresh_status()
-            # # 使用传入的 cloud 实例（若可用）
-            # cloud = self._cloud
-            # if cloud and hasattr(cloud, "get_device_status"):
-            #     try:
-            #         status = await cloud.get_device_status(self._device_id)
-            #         if isinstance(status, dict) and len(status) > 0:
-            #             for k, v in status.items():
-            #                 self.device.attributes[k] = v
-            #     except Exception as e:
-            #         MideaLogger.debug(f"Cloud status fetch failed: {e}")
+            # 检查是否为中央空调设备（T0x21）
+            if self.device.device_type == 0x21:
+                await self._poll_central_ac_state()
+            else:
+                await self.device.refresh_status()

            # 返回并推送当前状态
            updated = MideaDeviceData(
@@ -117,6 +111,76 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
                available=False,
                connected=False,
            )
+    
+    async def _poll_central_ac_state(self) -> None:
+        """轮询中央空调状态"""
+        try:
+            cloud = self._cloud
+            if cloud and hasattr(cloud, "get_central_ac_status"):
+                status_data = await cloud.get_central_ac_status([self._device_id])
+                if status_data and "appliances" in status_data:
+                    # 找到对应的设备数据并更新到设备属性中
+                    for appliance in status_data["appliances"]:
+                        if appliance.get("type") == "0x21" and "extraData" in appliance:
+                            extra_data = appliance["extraData"]
+                            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"]:
+                                    self.device._attributes["masterId"] = extra_data["attr"]["masterId"]
+                                if "modelid" in extra_data["attr"]:
+                                    self.device._attributes["modelid"] = extra_data["attr"]["modelid"]
+                                if "idType" in extra_data["attr"]:
+                                    self.device._attributes["idType"] = extra_data["attr"]["idType"]
+
+                                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():
+                                        # 尝试将数字字符串转换为数字
+                                        if key.find("temp") > -1:
+                                            try:
+                                                # 尝试转换为整数
+                                                if '.' not in value:
+                                                    self.device._attributes[key] = int(value)
+                                                else:
+                                                    # 尝试转换为浮点数
+                                                    self.device._attributes[key] = float(value)
+                                            except (ValueError, TypeError):
+                                                # 如果转换失败，保持原值
+                                                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}")

    async def async_set_attribute(self, attribute: str, value) -> None:
        """Set a device attribute."""
@@ -140,4 +204,147 @@ class MideaDataUpdateCoordinator(DataUpdateCoordinator[MideaDeviceData]):
            self.device.send_command(cmd_type, cmd_body_bytes)
        except ValueError as e:
            _LOGGER.error(f"Invalid command body: {e}")
-            raise
+            raise
+
+    async def async_send_central_ac_control(self, control: dict) -> bool:
+        """发送中央空调控制命令"""
+        try:
+            cloud = self._cloud
+            if cloud and hasattr(cloud, "send_central_ac_control"):
+                # 从设备属性中获取nodeid
+                masterid = self.device.attributes.get("masterId")
+                nodeid = self.device.attributes.get("nodeid")
+                modelid = self.device.attributes.get("modelid")
+                idtype = int(self.device.attributes.get("idType"))
+
+                if not nodeid:
+                    MideaLogger.warning(f"No nodeid found for central AC device {self._device_id}")
+                    return False
+                
+                # 构建完整的控制命令，包含centralized中的所有字段
+                full_control = self._build_full_central_ac_control(control)
+                MideaLogger.debug(f"Sending control to {self.device.device_name}: {full_control}")
+                success = await cloud.send_central_ac_control(
+                    masterid,
+                    nodeid,
+                    modelid,
+                    idtype,
+                    full_control
+                )
+
+                if success:
+                    # 更新本地状态
+                    self.device.attributes.update(control)
+                    self.mute_state_update_for_a_while()
+                    self.async_update_listeners()
+                    return True
+                else:
+                    MideaLogger.debug(f"Failed to send control to {self.device.device_name}")
+                    return False
+            else:
+                MideaLogger.debug("Cloud service not available for central AC control")
+                return False
+        except Exception as e:
+            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 = {}
+        full_control["run_mode"] = self.device.attributes.get("run_mode")
+        full_control["cooling_temp"] = str(self.device.attributes.get("cool_temp_set") or 26.0)
+        full_control["heating_temp"] = str(self.device.attributes.get("heat_temp_set") or 20.0)
+        full_control["fan_speed"] = self.device.attributes.get("fan_speed")
+        swing_mode = self.device.attributes.get("is_swing")
+        is_elec_heat = self.device.attributes.get("is_elec_heat")
+
+        if swing_mode == "1":
+            # 开启摆风：如果当前有电辅热(2)，则设为6(电辅热+摆风)，否则设为4(摆风)
+            if is_elec_heat == "1":
+                new_extflag = "6"  # 电辅热+摆风
+            else:
+                new_extflag = "4"  # 仅摆风
+        else:
+            # 关闭摆风：如果当前是6(电辅热+摆风)，则设为2(仅电辅热)，否则设为0(关闭)
+            if is_elec_heat == "1":
+                new_extflag = "2"  # 仅电辅热
+            else:
+                new_extflag = "0"  # 关闭
+
+        full_control["extflag"] = new_extflag
+
+        # 然后用新的控制值覆盖
+        full_control.update(new_control)
+        return full_control
--- a/custom_components/midea_auto_cloud/decrypt_lua.py
+++ b/custom_components/midea_auto_cloud/decrypt_lua.py
--- a/custom_components/midea_auto_cloud/device_mapping/T0x13.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0x13.py
@@ -0,0 +1,68 @@
+from homeassistant.const import Platform
+
+DEVICE_MAPPING = {
+    "default": {
+        "rationale": ["off", "on"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.LIGHT: {
+                "light": {
+                    "power": "power",
+                    "brightness": {"brightness": [1, 100]},
+                    "color_temp": {"color_temperature": [3000, 5700]},  # 添加色温配置
+                    "preset_modes": {
+                        "night": {"scene_light": "night"},
+                        "read": {"scene_light": "read"},
+                        "mild": {"scene_light": "mild"},
+                        "life": {"scene_light": "life"},
+                        "film": {"scene_light": "film"},
+                        "manual": {"scene_light": "manual"},
+                    }
+                }
+            }
+        }
+    },
+    "M0200015": {
+        "rationale": ["off", "on"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.LIGHT: {
+                "light": {
+                    "power": "led_power",
+                    "brightness": {"brightness": [1, 100]},
+                    "color_temp": {"color_temperature": [2700, 6500]},
+                    "preset_modes": {
+                        "work": {"led_scene_light": "work"},
+                        "eating": {"led_scene_light": "eating"},
+                        "film": {"led_scene_light": "film"},
+                        "night": {"led_scene_light": "night"},
+                        "ledmanual": {"led_scene_light": "ledmanual"},
+                    }
+                }
+            },
+            Platform.FAN: {
+                "fan": {
+                    "power": "fan_power",
+                    "speeds": [
+                        {"fan_speed": "1"},
+                        {"fan_speed": "2"},
+                        {"fan_speed": "3"},
+                        {"fan_speed": "4"},
+                        {"fan_speed": "5"},
+                        {"fan_speed": "6"},
+                    ],
+                    "preset_modes": {
+                        "breathing_wind": {"fan_scene": "breathing_wind"},
+                        "const_temperature": {"fan_scene": "const_temperature"},
+                        "fanmanual": {"fan_scene": "fanmanual"},
+                        "baby_wind": {"fan_scene": "baby_wind"},
+                        "sleep_wind": {"fan_scene": "sleep_wind"},
+                        "forest_wind": {"fan_scene": "forest_wind"}
+                    }
+                }
+            }
+        }
+    }
+}
--- a/custom_components/midea_auto_cloud/device_mapping/T0x21.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0x21.py
@@ -0,0 +1,106 @@
+from homeassistant.const import Platform, UnitOfTemperature, PRECISION_HALVES
+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": [{}],
+        "centralized": ["run_mode", "fan_speed", "cooling_temp", "heating_temp", "extflag"],
+        "entities": {
+            Platform.CLIMATE: {
+                "thermostat": {
+                    "power": "run_mode",
+                    "hvac_modes": {
+                        "off": {"run_mode": "0"},
+                        "fan_only": {"run_mode": "1"},
+                        "cool": {"run_mode": "2"},
+                        "heat": {"run_mode": "3"},
+                        "auto": {"run_mode": "4"},
+                        "dry": {"run_mode": "5"}
+                    },
+                    "fan_modes": {
+                        "off": {"fan_speed": "0"},
+                        "1": {"fan_speed": "1"},
+                        "2": {"fan_speed": "2"},
+                        "3": {"fan_speed": "3"},
+                        "4": {"fan_speed": "4"},
+                        "5": {"fan_speed": "5"},
+                        "6": {"fan_speed": "6"},
+                        "7": {"fan_speed": "7"},
+                        "auto": {"fan_speed": "8"}
+                    },
+                    "preset_modes": {
+                        "none": {"extflag": "0"},
+                        "electric_heat": {"extflag": "2"},
+                        "swing": {"extflag": "4"},
+                        "electric_heat_swing": {"extflag": "6"}
+                    },
+                    "target_temperature": ["temperature", "small_temperature"],
+                    "current_temperature": "room_temp",
+                    "pre_mode": "mode",
+                    "aux_heat": "ptc",
+                    "min_temp": 17,
+                    "max_temp": 30,
+                    "temperature_unit": UnitOfTemperature.CELSIUS,
+                    "precision": PRECISION_HALVES,
+                }
+            },
+            Platform.SWITCH: {
+                "is_lock_heat": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['0', '1']
+                },
+                "is_lock_cool": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['0', '1']
+                },
+                "fan_speed_lock": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['0', '1']
+                },
+                "is_lock_rc": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": ['0', '1']
+                },
+            },
+            Platform.SENSOR: {
+                "room_temp": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT,
+                    "precision": PRECISION_HALVES
+                },
+                "cool_temp_set": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT,
+                    "precision": PRECISION_HALVES
+                },
+                "heat_temp_set": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT,
+                    "precision": PRECISION_HALVES
+                },
+            }
+        }
+    }
+}
--- a/custom_components/midea_auto_cloud/device_mapping/T0x3D.py
+++ b/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
+                }
+            }
+        }
+    }
+}
--- a/custom_components/midea_auto_cloud/device_mapping/T0xA1.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xA1.py
@@ -25,6 +25,7 @@ DEVICE_MAPPING = {
                },
                "filter_tip": {
                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": [0, 1]
                },
            },
            Platform.HUMIDIFIER: {
--- a/custom_components/midea_auto_cloud/device_mapping/T0xAC.py
+++ b/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,
+                },
+            },
+        }
    }
 }
--- a/custom_components/midea_auto_cloud/device_mapping/T0xB6.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xB6.py
@@ -0,0 +1,34 @@
+from homeassistant.const import Platform
+from homeassistant.components.switch import SwitchDeviceClass
+
+DEVICE_MAPPING = {
+    "default": {
+        "rationale": ["off", "on"],
+        "queries": [{}],
+        "centralized": [],
+        "entities": {
+            Platform.SWITCH: {
+                "power": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "light": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "wisdom_wind": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                }
+            },
+            Platform.SELECT: {
+                "wind_pressure": {
+                    "options": {
+                        "off": {"wind_pressure": "0"},
+                        "low": {"wind_pressure": "1"},
+                        "medium": {"wind_pressure": "2"},
+                        "high": {"wind_pressure": "3"},
+                        "extreme": {"wind_pressure": "4"},
+                    }
+                },
+            },
+        }
+    }
+}
--- a/custom_components/midea_auto_cloud/device_mapping/T0xDC.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xDC.py
@@ -133,6 +133,9 @@ DEVICE_MAPPING = {
                }
            },
            Platform.SENSOR: {
+                "running_status": {
+                    "device_class": SensorDeviceClass.ENUM
+                },
                "appointment_time": {
                    "device_class": SensorDeviceClass.DURATION,
                    "unit_of_measurement": UnitOfTime.MINUTES,
--- a/custom_components/midea_auto_cloud/device_mapping/T0xED.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xED.py
@@ -182,12 +182,12 @@ DEVICE_MAPPING = {
                "water_consumption_today": {
                    "device_class": SensorDeviceClass.VOLUME,
                    "unit_of_measurement": UnitOfVolume.LITERS,
-                    "state_class": SensorStateClass.MEASUREMENT
+                    "state_class": SensorStateClass.TOTAL_INCREASING
                },
                "water_consumption_average": {
                    "device_class": SensorDeviceClass.VOLUME,
                    "unit_of_measurement": UnitOfVolume.LITERS,
-                    "state_class": SensorStateClass.MEASUREMENT
+                    "state_class": SensorStateClass.TOTAL_INCREASING
                },
                "soft_available_big": {
                    "device_class": SensorDeviceClass.VOLUME,
--- a/custom_components/midea_auto_cloud/device_mapping/T0xFA.py
+++ b/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
                }
--- a/custom_components/midea_auto_cloud/device_mapping/T0xFB.py
+++ b/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
+                }
+            }
+        }
+    }
+}
--- a/custom_components/midea_auto_cloud/device_mapping/T0xFD.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xFD.py
@@ -145,7 +145,7 @@ DEVICE_MAPPING = {
                    "state_class": SensorStateClass.MEASUREMENT
                },
                "tank_status": {
-                    "device_class": SensorDeviceClass.POWER_FACTOR,
+                    "device_class": SensorDeviceClass.BATTERY,
                    "unit_of_measurement": PERCENTAGE,
                    "state_class": SensorStateClass.MEASUREMENT
                }
--- a/custom_components/midea_auto_cloud/humidifier.py
+++ b/custom_components/midea_auto_cloud/humidifier.py
@@ -62,7 +62,7 @@ class MideaHumidifierEntity(MideaEntity, HumidifierEntity):
            config=config,
        )
        self._attr_supported_features = HumidifierEntityFeature.MODES
-        self._attr_available_modes = self._config.get("modes").keys()
+        self._attr_available_modes = list(self._config.get("modes").keys())

    @property
    def device_class(self):
@@ -124,13 +124,14 @@ class MideaHumidifierEntity(MideaEntity, HumidifierEntity):
        """Turn the humidifier on."""
        power_key = self._config.get("power")
        if power_key:
-            await self._device.set_attribute(power_key, True)
+            await self._device.set_attribute(power_key, self._rationale[int(True)])

    async def async_turn_off(self, **kwargs):
        """Turn the humidifier off."""
        power_key = self._config.get("power")
        if power_key:
-            await self._device.set_attribute(power_key, False)
+            await self._device.set_attribute(power_key, self._rationale[int(False)])
+            await self._device.set_attribute(power_key, self._rationale[int(False)])

    async def async_set_humidity(self, humidity: int):
        """Set the target humidity."""
--- a/custom_components/midea_auto_cloud/icons.json
+++ b/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"
+            }
+          }
+        }
+      }
+    }
+  }
+}
--- a/custom_components/midea_auto_cloud/light.py
+++ b/custom_components/midea_auto_cloud/light.py
@@ -0,0 +1,283 @@
+from homeassistant.components.light import LightEntity, LightEntityFeature, ColorMode
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
+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
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    account_bucket = hass.data.get(DOMAIN, {}).get("accounts", {}).get(config_entry.entry_id)
+    if not account_bucket:
+        async_add_entities([])
+        return
+    device_list = account_bucket.get("device_list", {})
+    coordinator_map = account_bucket.get("coordinator_map", {})
+
+    devs = []
+    for device_id, info in device_list.items():
+        device_type = info.get("type")
+        sn8 = info.get("sn8")
+        config = await load_device_config(hass, device_type, sn8) or {}
+        entities_cfg = (config.get("entities") or {}).get(Platform.LIGHT, {})
+        manufacturer = config.get("manufacturer")
+        rationale = config.get("rationale")
+        coordinator = coordinator_map.get(device_id)
+        device = coordinator.device if coordinator else None
+        for entity_key, ecfg in entities_cfg.items():
+            devs.append(MideaLightEntity(coordinator, device, manufacturer, rationale, entity_key, ecfg))
+    async_add_entities(devs)
+
+
+class MideaLightEntity(MideaEntity, LightEntity):
+    def __init__(self, coordinator, device, manufacturer, rationale, entity_key, config):
+        super().__init__(
+            coordinator,
+            device.device_id,
+            device.device_name,
+            f"T0x{device.device_type:02X}",
+            device.sn,
+            device.sn8,
+            device.model,
+            entity_key,
+            device=device,
+            manufacturer=manufacturer,
+            rationale=rationale,
+            config=config,
+        )
+        self._key_power = self._config.get("power")
+        self._key_preset_modes = self._config.get("preset_modes")
+        self._key_brightness = self._config.get("brightness")
+        self._key_color_temp = self._config.get("color_temp")
+        self._key_oscillate = self._config.get("oscillate")
+        self._key_directions = self._config.get("directions")
+
+        # 检测亮度配置类型：范围 [min, max] 或嵌套格式 {"brightness": [min, max]}
+        self._brightness_is_range = False
+        self._brightness_min = 0
+        self._brightness_max = 255
+        self._brightness_key = "brightness"  # 默认键名
+        
+        if self._key_brightness:
+            if isinstance(self._key_brightness, list) and len(self._key_brightness) == 2:
+                # 直接范围格式：[min, max]
+                if isinstance(self._key_brightness[0], (int, float)) and isinstance(self._key_brightness[1], (int, float)):
+                    self._brightness_is_range = True
+                    self._brightness_min = self._key_brightness[0]
+                    self._brightness_max = self._key_brightness[1]
+            elif isinstance(self._key_brightness, dict):
+                # 嵌套格式：{"brightness": [min, max]} 或其他键名
+                for key, value in self._key_brightness.items():
+                    if isinstance(value, list) and len(value) == 2:
+                        if isinstance(value[0], (int, float)) and isinstance(value[1], (int, float)):
+                            self._brightness_is_range = True
+                            self._brightness_min = value[0]
+                            self._brightness_max = value[1]
+                            self._brightness_key = key
+                            break
+
+        # 检测色温配置类型：范围 [min_kelvin, max_kelvin] 或嵌套格式 {"color_temp": [min_kelvin, max_kelvin]}
+        self._color_temp_is_range = False
+        self._color_temp_min = 2700  # 默认最小色温（暖白）
+        self._color_temp_max = 6500  # 默认最大色温（冷白）
+        self._color_temp_key = "color_temp"  # 默认键名
+        
+        if self._key_color_temp:
+            if isinstance(self._key_color_temp, list) and len(self._key_color_temp) == 2:
+                # 直接范围格式：[min_kelvin, max_kelvin]
+                if isinstance(self._key_color_temp[0], (int, float)) and isinstance(self._key_color_temp[1], (int, float)):
+                    self._color_temp_is_range = True
+                    self._color_temp_min = self._key_color_temp[0]
+                    self._color_temp_max = self._key_color_temp[1]
+            elif isinstance(self._key_color_temp, dict):
+                # 嵌套格式：{"color_temp": [min_kelvin, max_kelvin]} 或其他键名
+                for key, value in self._key_color_temp.items():
+                    if isinstance(value, list) and len(value) == 2:
+                        if isinstance(value[0], (int, float)) and isinstance(value[1], (int, float)):
+                            self._color_temp_is_range = True
+                            self._color_temp_min = value[0]
+                            self._color_temp_max = value[1]
+                            self._color_temp_key = key
+                            break
+
+    @property
+    def supported_features(self):
+        features = LightEntityFeature(0)
+        if self._key_preset_modes is not None and len(self._key_preset_modes) > 0:
+            features |= LightEntityFeature.EFFECT
+        return features
+
+    @property
+    def supported_color_modes(self):
+        """返回支持的色彩模式"""
+        modes = set()
+        if self._brightness_is_range and self._color_temp_is_range:
+            # 如果同时支持亮度和色温，优先支持色温模式（更高级的功能）
+            modes.add(ColorMode.COLOR_TEMP)
+        elif self._brightness_is_range:
+            modes.add(ColorMode.BRIGHTNESS)
+        elif self._color_temp_is_range:
+            modes.add(ColorMode.COLOR_TEMP)
+        else:
+            modes.add(ColorMode.ONOFF)
+        return modes
+
+    @property
+    def color_mode(self):
+        """返回当前色彩模式"""
+        if self._brightness_is_range and self._color_temp_is_range:
+            # 如果同时支持亮度和色温，优先返回色温模式（与supported_color_modes保持一致）
+            return ColorMode.COLOR_TEMP
+        elif self._brightness_is_range:
+            return ColorMode.BRIGHTNESS
+        elif self._color_temp_is_range:
+            return ColorMode.COLOR_TEMP
+        return ColorMode.ONOFF
+
+    @property
+    def is_on(self) -> bool:
+        return self._get_status_on_off(self._key_power)
+
+    @property
+    def effect_list(self):
+        return list(self._key_preset_modes.keys())
+
+    @property
+    def effect(self):
+        return self._dict_get_selected(self._key_preset_modes)
+
+    @property
+    def brightness(self):
+        """返回0-255范围内的亮度值（Home Assistant标准）"""
+        if not self._brightness_is_range:
+            return None
+            
+        # 范围模式：从设备属性读取亮度值，使用配置的键名
+        brightness_value = self._get_nested_value(self._brightness_key)
+        if brightness_value is not None:
+            brightness_value = int(brightness_value)
+        if brightness_value is not None:
+            # 如果配置是[0, 255]但实际设备范围是1-100，需要特殊处理
+            if self._brightness_min == 0 and self._brightness_max == 255:
+                # 特殊处理：设备1-100范围映射到HA的0-255范围
+                ha_brightness = round(brightness_value * 2.55)  # 1-100 -> 0-255
+                return max(1, min(255, ha_brightness))
+            else:
+                # 正常范围映射
+                device_range = self._brightness_max - self._brightness_min
+                if device_range > 0:
+                    ha_brightness = round((brightness_value - self._brightness_min) * 255 / device_range)
+                    return max(1, min(255, ha_brightness))
+        return None
+
+    @property
+    def color_temp_kelvin(self):
+        """返回当前色温值（开尔文）"""
+        if not self._color_temp_is_range:
+            return None
+            
+        # 从设备属性读取色温值（1-100范围）
+        color_temp_value = self._get_nested_value(self._color_temp_key)
+        if color_temp_value is not None:
+            try:
+                device_color_temp = int(color_temp_value)
+                # 将设备的1-100值转换为开尔文值
+                kelvin_range = self._color_temp_max - self._color_temp_min
+                if kelvin_range > 0:
+                    # 将1-100范围映射回开尔文范围
+                    ha_color_temp = self._color_temp_min + device_color_temp * kelvin_range / 100
+                    return round(ha_color_temp)
+                else:
+                    return self._color_temp_min
+            except (ValueError, TypeError):
+                return None
+        return None
+
+    @property
+    def min_color_temp_kelvin(self):
+        """返回支持的最小色温值（开尔文）"""
+        if self._color_temp_is_range:
+            return self._color_temp_min
+        return None
+
+    @property
+    def max_color_temp_kelvin(self):
+        """返回支持的最大色温值（开尔文）"""
+        if self._color_temp_is_range:
+            return self._color_temp_max
+        return None
+
+    async def async_turn_on(
+            self,
+            brightness: int | None = None,
+            brightness_pct: int | None = None,
+            percentage: int | None = None,
+            color_temp_kelvin: int | None = None,
+            effect: str | None = None,
+            preset_mode: str | None = None,
+            **kwargs,
+    ):
+        new_status = {}
+        if effect is not None and self._key_preset_modes is not None:
+            effect_config = self._key_preset_modes.get(effect, {})
+            new_status.update(effect_config)
+        
+        # 处理亮度设置 - 支持多种参数格式
+        target_brightness = None
+        if brightness is not None:
+            # Home Assistant标准：0-255范围
+            target_brightness = brightness
+        elif brightness_pct is not None:
+            # 百分比格式：0-100范围，转换为0-255
+            target_brightness = round(brightness_pct * 255 / 100)
+        elif percentage is not None:
+            # 兼容旧格式：0-100范围，转换为0-255
+            target_brightness = round(percentage * 255 / 100)
+            
+        if target_brightness is not None and self._key_brightness and self._brightness_is_range:
+            # 范围模式：将Home Assistant的0-255映射到设备范围
+            # 如果配置是[0, 255]但实际设备范围是1-100，需要特殊处理
+            if self._brightness_min == 0 and self._brightness_max == 255:
+                # 特殊处理：配置[0,255]但实际设备范围是1-100
+                device_brightness = round(target_brightness / 2.55)  # 0-255 -> 0-100
+                device_brightness = max(1, min(100, device_brightness))  # 确保在1-100范围内
+            else:
+                # 正常范围映射
+                device_range = self._brightness_max - self._brightness_min
+                if device_range > 0:
+                    device_brightness = round(self._brightness_min + (target_brightness / 255.0) * device_range)
+                    device_brightness = max(self._brightness_min, min(self._brightness_max, device_brightness))
+                else:
+                    return
+            new_status[self._brightness_key] = device_brightness
+        
+        # 处理色温设置
+        if color_temp_kelvin is not None and self._color_temp_is_range:
+            # 确保色温值在配置的范围内
+            ha_color_temp = max(self._color_temp_min, min(self._color_temp_max, color_temp_kelvin))
+            
+            # 将开尔文值转换为设备范围（1-100）
+            kelvin_range = self._color_temp_max - self._color_temp_min
+            if kelvin_range > 0:
+                # 将开尔文值映射到1-100范围
+                device_color_temp = round((ha_color_temp - self._color_temp_min) * 100 / kelvin_range)
+                device_color_temp = max(0, min(100, device_color_temp))
+            else:
+                device_color_temp = 50  # 默认中间值
+            
+            new_status[self._color_temp_key] = str(device_color_temp)
+                
+        await self._async_set_status_on_off(self._key_power, True)
+        if new_status:
+            await self.async_set_attributes(new_status)
+
+    async def async_turn_off(self):
+        await self._async_set_status_on_off(self._key_power, False)
--- a/custom_components/midea_auto_cloud/manifest.json
+++ b/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.8"
+  "version": "v0.1.14"
 }
--- a/custom_components/midea_auto_cloud/switch.py
+++ b/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)
--- a/custom_components/midea_auto_cloud/translations/en.json
+++ b/custom_components/midea_auto_cloud/translations/en.json
@@ -291,38 +291,11 @@
      "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"
      },
      "standby_status": {
        "name": "Standby Status"
-      },
-      "tank_status": {
-        "name": "Tank Status"
      }
    },
    "climate": {
@@ -339,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": {
@@ -354,6 +349,12 @@
      }
    },
    "select": {
+      "warm_target_temp": {
+        "name": "Warm Target Temperature"
+      },
+      "boil_target_temp": {
+        "name": "Boil Target Temperature"
+      },
      "add_rinse": {
        "name": "Add Rinse"
      },
@@ -623,9 +624,18 @@
      },
      "power_off_time": {
        "name": "Power Off Time"
+      },
+      "wind_pressure": {
+        "name": "Wind Pressure"
      }
    },
    "sensor": {
+      "running_status": {
+        "name": "Running Status"
+      },
+      "tank_status": {
+        "name": "Tank Status"
+      },
      "fan_level": {
        "name": "Fan Level"
      },
@@ -1483,9 +1493,34 @@
      },
      "water_full_level": {
        "name": "Water Full Level"
+      },
+      "room_temp": {
+        "name": "Room Temperature"
+      },
+      "cool_temp_set": {
+        "name": "Cool Temperature Set"
+      },
+      "heat_temp_set": {
+        "name": "Heat Temperature Set"
+      }
+    },
+    "light": {
+      "light": {
+        "name": "Light"
+      }
+    },
+    "fan": {
+      "fan": {
+        "name": "Fan"
      }
    },
    "switch": {
+      "temp_wind_switch": {
+        "name": "Wind Change with Temperature"
+      },
+      "screen_close": {
+        "name": "Screen Close"
+      },
      "anion": {
        "name": "Anion"
      },
@@ -2325,7 +2360,46 @@
      },
      "cold_water_master": {
        "name": "Cold Water Master"
+      },
+      "is_lock_heat": {
+        "name": "Heat Lock"
+      },
+      "is_lock_cool": {
+        "name": "Cool Lock"
+      },
+      "fan_speed_lock": {
+        "name": "Fan Speed Lock"
+      },
+      "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"
      }
    }
  }
-}
+}
--- a/custom_components/midea_auto_cloud/translations/zh-Hans.json
+++ b/custom_components/midea_auto_cloud/translations/zh-Hans.json
@@ -291,38 +291,11 @@
      "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": "加热状态"
      },
      "standby_status": {
        "name": "待机状态"
-      },
-      "tank_status": {
-        "name": "水箱状态"
      }
    },
    "climate": {
@@ -339,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": {
@@ -354,6 +353,12 @@
      }
    },
    "select": {
+      "warm_target_temp": {
+        "name": "保温目标温度"
+      },
+      "boil_target_temp": {
+        "name": "煮沸目标温度"
+      },
      "add_rinse": {
        "name": "加漂洗"
      },
@@ -623,9 +628,18 @@
      },
      "power_off_time": {
        "name": "关机时间"
+      },
+      "wind_pressure": {
+        "name": "风压"
      }
    },
    "sensor": {
+      "running_status": {
+        "name": "运行状态"
+      },
+      "tank_status": {
+        "name": "水箱状态"
+      },
      "fan_level": {
        "name": "风扇档位"
      },
@@ -1483,9 +1497,34 @@
      },
      "water_full_level": {
        "name": "满水水位"
+      },
+      "room_temp": {
+        "name": "室内温度"
+      },
+      "cool_temp_set": {
+        "name": "制冷设定温度"
+      },
+      "heat_temp_set": {
+        "name": "制热设定温度"
+      }
+    },
+    "light": {
+      "light": {
+        "name": "电灯"
+      }
+    },
+    "fan": {
+      "fan": {
+        "name": "风扇"
      }
    },
    "switch": {
+      "temp_wind_switch": {
+        "name": "风随温变"
+      },
+      "screen_close": {
+        "name": "屏幕关闭"
+      },
      "anion": {
        "name": "负离子"
      },
@@ -2325,6 +2364,45 @@
      },
      "cold_water_master": {
        "name": "单次零冷水"
+      },
+      "is_lock_heat": {
+        "name": "制热锁定"
+      },
+      "is_lock_cool": {
+        "name": "制冷锁定"
+      },
+      "fan_speed_lock": {
+        "name": "风速锁定"
+      },
+      "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": "工作开关"
      }
    }
  }
--- a/img/img.png
+++ b/img/img.png
--- a/img/img_1.png
+++ b/img/img_1.png
--- a/img/img_2.png
+++ b/img/img_2.png
--- a/img/img_3.png
+++ b/img/img_3.png
Author	SHA1	Message	Date
sususweet	aa553cd3a8	feat: version v0.1.14	2025-10-28 22:47:39 +08:00
sususweet	7ee22880ab	feat: add support for T0xFA.	2025-10-28 22:44:58 +08:00
sususweet	e941dfc547	Merge remote-tracking branch 'origin/master'	2025-10-28 22:04:45 +08:00
sususweet	059cf3aebf	feat: add device support for T0xAC(106J6363).	2025-10-28 22:04:27 +08:00
Yingqi Tang	48fac5ec42	Refactor device mapping for default configuration.	2025-10-28 16:16:40 +08:00
sususweet	c503b14d33	feat: add device support for T0x3D.	2025-10-27 23:05:30 +08:00
sususweet	171d76ee3e	feat: add device support for T0x21 switch.	2025-10-27 22:38:12 +08:00
sususweet	087c5db497	feat: add device support for T0xFB.	2025-10-22 16:01:20 +08:00
sususweet	7327ee3433	feat: update readme.	2025-10-21 16:01:48 +08:00
sususweet	47df52654a	Merge pull request #32 from asakiasako/feature/add-colmo-turing-central-AC feat: Add COLMO Turing Central AC	2025-10-20 09:57:30 +08:00
Setsuna	b2bf61f85c	readability optimization	2025-10-18 23:30:26 +08:00
Setsuna	80e646637a	feat: Add COLMO Turing Central AC 1. Add device mapping of multiple Turing ACs in T0xAC.py 2. Necessary changes in load_device_config() to support tuple or re pattern as the device map key 3. Update in climate.py to support target humidity feature 4. Add missing translations and icons	2025-10-16 00:27:04 +08:00
sususweet	224d6b0bbc	feat: fix device support for T0x13.	2025-10-14 20:37:39 +08:00
sususweet	341796a8d4	feat: fix device support for T0x13.	2025-10-14 20:36:27 +08:00
sususweet	57b5cf811c	Merge remote-tracking branch 'origin/master'	2025-10-14 20:30:07 +08:00
sususweet	187c46168c	feat: add device support for T0x13.	2025-10-14 20:29:35 +08:00
sususweet	6491570e70	Merge pull request #30 from zy900906/master 传感器增加running_status	2025-10-13 23:10:07 +08:00
zy900906	a5d40b7d65	Update en.json sensor,running_status	2025-10-13 12:47:47 +08:00
zy900906	d8c298f608	Update zh-Hans.json sensor,running_status	2025-10-13 12:46:49 +08:00
zy900906	85c51c2090	Update T0xDC.py running_status	2025-10-13 12:44:20 +08:00
sususweet	b1e42526f6	feat: add device for central air conditioner gateway(T0x21).	2025-10-12 12:53:13 +08:00
sususweet	b87729d016	fix: resolve error when lua file is none	2025-10-11 23:52:54 +08:00
sususweet	1172f66a17	feat: version 0.1.10	2025-10-11 20:53:03 +08:00
sususweet	1ddfa9f020	feat: update device mapping for T0xB6. Fix #26 .	2025-10-11 20:44:33 +08:00
sususweet	160957abb8	feat: update translation	2025-10-11 14:59:16 +08:00
sususweet	69098292f0	feat: update contribution doc.	2025-10-11 14:21:11 +08:00
sususweet	b3e9a11394	fix: humidifier entity control mapping.	2025-10-11 11:48:42 +08:00