feat: add device support for T0xFB.

feat: update readme.
Merge pull request #32 from asakiasako/feature/add-colmo-turing-central-AC
2025-11-12 16:01:54 +00:00 · 2025-10-22 16:01:20 +08:00 · 2025-10-21 16:01:48 +08:00 · 2025-10-20 09:57:30 +08:00 · 2025-10-18 23:30:26 +08:00 · 2025-10-16 00:27:04 +08:00
35 changed files with 1850 additions and 408 deletions
--- a/.github/workflows/validate.yml
+++ b/.github/workflows/validate.yml
@@ -0,0 +1,23 @@
+name: Validate
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: 0 0 * * *
+
+jobs:
+  hassfest:
+    name: hassfest
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: home-assistant/actions/hassfest@master
+  hacs:
+    name: HACS
+    runs-on: ubuntu-latest
+    steps:
+      - name: HACS Action
+        uses: hacs/action@main
+        with:
+          category: integration
--- 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,52 +1,64 @@
 # 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 浴霸
- T0xAC 空调
- T0xB2 电蒸箱
- T0xB3 消毒碗柜
- T0xB8 智能扫地机器人
- T0xCA 对开门冰箱
- 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
+- 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
@@ -55,8 +67,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,74 @@
+# 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 浴霸
+- 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/config_flow.py
+++ b/custom_components/midea_auto_cloud/config_flow.py
@@ -44,9 +44,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
            )
            try:
                if await cloud.login():
-                    await self.async_set_unique_id(user_input[CONF_ACCOUNT])
-                    self._abort_if_unique_id_configured()
-                    
+
                    # 保存云实例和用户输入，用于后续步骤
                    self._cloud = cloud
                    self._user_input = user_input
--- a/custom_components/midea_auto_cloud/core/cloud.py
+++ b/custom_components/midea_auto_cloud/core/cloud.py
@@ -198,6 +198,14 @@ 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()


 class MeijuCloud(MideaCloud):
@@ -223,6 +231,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 +284,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 +315,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 +344,66 @@ 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 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,51 @@ 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 and "state" in extra_data["attr"]:
+                                state = extra_data["attr"]["state"]
+
+                                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 "condition_attribute" in 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
+                                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 +179,75 @@ 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
+
+    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",
+                    "fan_speed": [
+                        {"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,89 @@
+from homeassistant.const import Platform, UnitOfTemperature, PRECISION_HALVES
+from homeassistant.components.sensor import SensorStateClass, SensorDeviceClass
+from homeassistant.components.switch import SwitchDeviceClass
+
+DEVICE_MAPPING = {
+    "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/T0xA1.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xA1.py
@@ -0,0 +1,92 @@
+from homeassistant.components.humidifier import HumidifierDeviceClass
+from homeassistant.const import Platform, UnitOfTime
+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: {
+                "power": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "anion": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "child_lock": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "wind_swing_ud": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "filter_tip": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                    "rationale": [0, 1]
+                },
+            },
+            Platform.HUMIDIFIER: {
+                "dehumidifier": {
+                    "device_class": HumidifierDeviceClass.HUMIDIFIER,
+                    "power": "power",
+                    "target_humidity": "humidity",
+                    "current_humidity": "cur_humidity",
+                    "min_humidity": 35,
+                    "max_humidity": 85,
+                    "mode": "mode",
+                    "modes": {
+                        "continuity": {"mode": "continuity"},
+                        "auto": {"mode": "auto"},
+                        "fan": {"mode": "fan"},
+                        "dry_shoes": {"mode": "dry_shoes"},
+                        "dry_clothes": {"mode": "dry_clothes"}
+                    }
+                }
+            },
+            Platform.BINARY_SENSOR: {
+                "tank_status": {
+                    "device_class": BinarySensorDeviceClass.PROBLEM
+                }
+            },
+            Platform.SELECT: {
+                "wind_speed": {
+                    "options": {
+                        "low": {"wind_speed": "30"},
+                        "high": {"wind_speed": "80"},
+                    }
+                },
+                "power_on_time": {
+                     "options": {
+                        "off": {"power_on_timer": "off"},
+                        "15": {"power_on_timer": "on", "power_on_time_value": "15"},
+                        "30": {"power_on_timer": "on", "power_on_time_value": "30"},
+                        "45": {"power_on_timer": "on", "power_on_time_value": "45"},
+                        "60": {"power_on_timer": "on", "power_on_time_value": "60"},
+                    }
+                },
+                "power_off_time": {
+                    "options": {
+                        "off": {"power_off_timer": "off"},
+                        "15": {"power_off_timer": "on", "power_off_time_value": "15"},
+                        "30": {"power_off_timer": "on", "power_off_time_value": "30"},
+                        "45": {"power_off_timer": "on", "power_off_time_value": "45"},
+                        "60": {"power_off_timer": "on", "power_off_time_value": "60"},
+                    }
+                },
+            },
+            Platform.SENSOR: {
+                "water_full_time": {
+                    "device_class": SensorDeviceClass.DURATION,
+                    "unit_of_measurement": UnitOfTime.MINUTES,
+                    "state_class": SensorStateClass.MEASUREMENT
+                },
+                "water_full_level": {
+                    "device_class": SensorDeviceClass.ENUM
+                },
+            }
+        }
+    }
+}
--- a/custom_components/midea_auto_cloud/device_mapping/T0xAC.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xAC.py
@@ -132,6 +132,55 @@ DEVICE_MAPPING = {
            }
        }
    },
+    "26093139": {
+        "rationale": [0, 3],
+        "queries": [{}, {"query_type": "run_status"}],
+        "centralized": ["fresh_air", "fresh_air_mode", "fresh_air_fan_speed", "fresh_air_temp"],
+        "entities": {
+            Platform.FAN: {
+                "fan": {
+                    "power": "fresh_air",
+                    "speeds": [
+                        {"fresh_air": 3, "fresh_air_fan_speed": 20},
+                        {"fresh_air": 3, "fresh_air_fan_speed": 40},
+                        {"fresh_air": 3, "fresh_air_fan_speed": 60},
+                        {"fresh_air": 3, "fresh_air_fan_speed": 80},
+                        {"fresh_air": 3, "fresh_air_fan_speed": 100},
+                    ],
+                    "preset_modes": {
+                        "heat_exchange": {
+                            "fresh_air_mode": 1,
+                            "wind_strength": 0
+                        },
+                        "smooth_in": {
+                            "fresh_air_mode": 2,
+                            "wind_strength": 0
+                        },
+                        "rough_in": {
+                            "fresh_air_mode": 2,
+                            "wind_strength": 1
+                        },
+                        "smooth_out": {
+                            "fresh_air_mode": 3,
+                            "wind_strength": 0
+                        },
+                        "rough_out": {
+                            "fresh_air_mode": 3,
+                            "wind_strength": 1
+                        },
+                        "auto": {
+                            "fresh_air_mode": 4,
+                            "wind_strength": 0
+                        },
+                        "innercycle": {
+                            "fresh_air_mode": 5,
+                            "wind_strength": 0
+                        },
+                    }
+                }
+            },
+        }
+    },
    "22012227": {
        "rationale": ["off", "on"],
        "queries": [{}],
@@ -218,5 +267,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/T0xB8.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xB8.py
@@ -38,7 +38,9 @@ DEVICE_MAPPING = {
                        "work": {"work_status": "work"},
                        "video_cruise_start": {"work_status": "video_cruise_start"},
                        "video_cruise_pause": {"work_status": "video_cruise_pause"},
-                        "quickly_build_map": {"work_status": "quickly_build_map"},
+                        "mop_clean": {"mop_clean_setting": {"mode_type": "common", "clean_level": "normal"}},
+                        "dry_mop_on": {"work_status": "dry_mop", "switch": "on"},
+                        "dry_mop_off": {"work_status": "dry_mop", "switch": "off"},
                    }
                },
                "water_tank_setting": {
@@ -58,18 +60,15 @@ DEVICE_MAPPING = {
                }
            },
            Platform.SENSOR: {
-                "control_type": {
+                "fan_level": {
                    "device_class": SensorDeviceClass.ENUM
                },
-                "mop_status": {
+                "mop": {
                    "device_class": SensorDeviceClass.ENUM
                },
                "sub_work_status": {
                    "device_class": SensorDeviceClass.ENUM
                },
-                "query_type": {
-                    "device_class": SensorDeviceClass.ENUM
-                },
                "move_direction": {
                    "device_class": SensorDeviceClass.ENUM
                },
--- a/custom_components/midea_auto_cloud/device_mapping/T0xCA.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xCA.py
@@ -11,7 +11,7 @@ DEVICE_MAPPING = {
            "freezing_mode", "intelligent_mode", "energy_saving_mode", "holiday_mode",
            "moisturize_mode", "preservation_mode", "acme_freezing_mode", "variable_mode",
            "storage_power", "left_flexzone_power", "right_flexzone_power", "freezing_power",
-            "function_zone_power", "storage_temperature", "freezing_temperature",
+            "storage_temperature", "freezing_temperature",
            "left_flexzone_temperature", "right_flexzone_temperature"
        ],
        "entities": {
@@ -49,9 +49,6 @@ DEVICE_MAPPING = {
                "freezing_power": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
-                "function_zone_power": {
-                    "device_class": SwitchDeviceClass.SWITCH,
-                },
                "cross_peak_electricity": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
@@ -138,7 +135,7 @@ DEVICE_MAPPING = {
                    "power": "storage_power",
                    "hvac_modes": {
                        "off": {"storage_power": "off"},
-                        "heat": {"storage_power": "on"}
+                        "cool": {"storage_power": "on"}
                    },
                    "target_temperature": "storage_temperature",
                    "current_temperature": "refrigeration_real_temperature",
@@ -152,7 +149,7 @@ DEVICE_MAPPING = {
                    "power": "freezing_power",
                    "hvac_modes": {
                        "off": {"freezing_power": "off"},
-                        "heat": {"freezing_power": "on"}
+                        "cool": {"freezing_power": "on"}
                    },
                    "target_temperature": "freezing_temperature",
                    "current_temperature": "freezing_real_temperature",
@@ -165,7 +162,7 @@ DEVICE_MAPPING = {
                    "power": "left_flexzone_power",
                    "hvac_modes": {
                        "off": {"left_flexzone_power": "off"},
-                        "heat": {"left_flexzone_power": "on"}
+                        "cool": {"left_flexzone_power": "on"}
                    },
                    "target_temperature": "left_flexzone_temperature",
                    "current_temperature": "left_variable_real_temperature",
@@ -178,7 +175,7 @@ DEVICE_MAPPING = {
                    "power": "right_flexzone_power",
                    "hvac_modes": {
                        "off": {"right_flexzone_power": "off"},
-                        "heat": {"right_flexzone_power": "on"}
+                        "cool": {"right_flexzone_power": "on"}
                    },
                    "target_temperature": "right_flexzone_temperature",
                    "current_temperature": "right_variable_real_temperature",
@@ -192,26 +189,27 @@ DEVICE_MAPPING = {
                "variable_mode": {
                    "options": {
                        "none_mode": {"variable_mode": "none_mode"},
-                        "freezing": {"variable_mode": "freezing"},
-                        "refrigeration": {"variable_mode": "refrigeration"},
-                        "wine": {"variable_mode": "wine"},
-                        "vegetable": {"variable_mode": "vegetable"}
+                        "soft_freezing_mode": {"variable_mode": "soft_freezing_mode"},
+                        "zero_fresh_mode": {"variable_mode": "zero_fresh_mode"},
+                        "cold_drink_mode": {"variable_mode": "cold_drink_mode"},
+                        "fresh_product_mode": {"variable_mode": "fresh_product_mode"},
+                        "partial_freezing_mode": {"variable_mode": "partial_freezing_mode"},
+                        "dry_zone_mode": {"variable_mode": "dry_zone_mode"},
+                        "freeze_warm_mode": {"variable_mode": "freeze_warm_mode"},
+                        "freeze_mode": {"variable_mode": "freeze_mode"},
                    }
                },
                "icea_bar_function_switch": {
                    "options": {
                        "default": {"icea_bar_function_switch": "default"},
-                        "ice": {"icea_bar_function_switch": "ice"},
-                        "water": {"icea_bar_function_switch": "water"},
-                        "off": {"icea_bar_function_switch": "off"}
+                        "refrigeration": {"icea_bar_function_switch": "refrigeration"},
+                        "freezing": {"icea_bar_function_switch": "freezing"},
                    }
                },
                "food_site": {
                    "options": {
                        "left_freezing_room": {"food_site": "left_freezing_room"},
                        "right_freezing_room": {"food_site": "right_freezing_room"},
-                        "storage_room": {"food_site": "storage_room"},
-                        "function_zone": {"food_site": "function_zone"}
                    }
                },
                "temperature_unit": {
@@ -222,9 +220,6 @@ DEVICE_MAPPING = {
                }
            },
            Platform.SENSOR: {
-                "mode": {
-                    "device_class": SensorDeviceClass.ENUM,
-                },
                "storage_temperature": {
                    "device_class": SensorDeviceClass.TEMPERATURE,
                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
--- 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/T0xE1.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xE1.py
@@ -19,9 +19,6 @@ DEVICE_MAPPING = {
                "uvswitch": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
-                "doorswitch": {
-                    "device_class": SwitchDeviceClass.SWITCH,
-                },
                "dryswitch": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
@@ -30,6 +27,9 @@ DEVICE_MAPPING = {
                }
            },
            Platform.BINARY_SENSOR: {
+                "doorswitch": {
+                    "device_class": BinarySensorDeviceClass.RUNNING,
+                },
                "air_status": {
                    "device_class": BinarySensorDeviceClass.RUNNING,
                },
@@ -59,6 +59,16 @@ DEVICE_MAPPING = {
                },
            },
            Platform.SELECT: {
+                "air_set_hour": {
+                     "options": {
+                        "12": {"air_set_hour": "12" },
+                        "24": {"air_set_hour": "24" },
+                        "36": {"air_set_hour": "36" },
+                        "48": {"air_set_hour": "48" },
+                        "60": {"air_set_hour": "60" },
+                        "72": {"air_set_hour": "72" },
+                    }
+                },
                "work_status": {
                    "options": {
                        "power_off": {"work_status": "power_off" },
@@ -96,9 +106,7 @@ DEVICE_MAPPING = {
            },
            Platform.SENSOR: {
                "bright": {
-                    "device_class": SensorDeviceClass.ILLUMINANCE,
-                    "unit_of_measurement": "lx",
-                    "state_class": SensorStateClass.MEASUREMENT
+                    "device_class": SensorDeviceClass.ENUM
                },
                "temperature": {
                    "device_class": SensorDeviceClass.TEMPERATURE,
@@ -106,20 +114,13 @@ DEVICE_MAPPING = {
                    "state_class": SensorStateClass.MEASUREMENT
                },
                "softwater": {
-                    "device_class": SensorDeviceClass.TEMPERATURE,
-                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
-                    "state_class": SensorStateClass.MEASUREMENT
+                    "device_class": SensorDeviceClass.ENUM
                },
                "left_time": {
                    "device_class": SensorDeviceClass.DURATION,
                    "unit_of_measurement": UnitOfTime.MINUTES,
                    "state_class": SensorStateClass.MEASUREMENT
                },
-                "air_set_hour": {
-                    "device_class": SensorDeviceClass.DURATION,
-                    "unit_of_measurement": UnitOfTime.HOURS,
-                    "state_class": SensorStateClass.MEASUREMENT
-                },
                "air_left_hour": {
                    "device_class": SensorDeviceClass.DURATION,
                    "unit_of_measurement": UnitOfTime.HOURS,
--- a/custom_components/midea_auto_cloud/device_mapping/T0xE3.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xE3.py
@@ -7,19 +7,14 @@ DEVICE_MAPPING = {
    "default": {
        "rationale": ["off", "on"],
        "queries": [{}],
-        "centralized": [
-            "power", "bubble", "cold_water", "bathtub", "safe", "cold_water_dot",
-            "change_litre_switch", "cold_water_ai", "cold_water_pressure",
-            "person_mode_one", "person_mode_two", "person_mode_three", "gesture_function",
-            "mode", "power_level", "type_machine", "capacity", "temperature"
-        ],
+        "centralized": [],
        "entities": {
            Platform.SWITCH: {
                "bubble": {
                    "device_class": SwitchDeviceClass.SWITCH,
                    "rationale": [0, 1]
                },
-                "cold_water": {
+                "cold_water_master": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
                "bathtub": {
@@ -49,9 +44,9 @@ DEVICE_MAPPING = {
                "person_mode_three": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
-                "gesture_function": {
-                    "device_class": SwitchDeviceClass.SWITCH,
-                }
+                # "gesture_function": {
+                #     "device_class": SwitchDeviceClass.SWITCH,
+                # }
            },
            Platform.CLIMATE: {
                "water_heater": {
@@ -74,39 +69,48 @@ DEVICE_MAPPING = {
                        "shower": {"mode": "shower"},
                        "bath": {"mode": "bath"},
                        "mixed": {"mode": "mixed"},
-                        "eco": {"mode": "eco"}
+                        "eco": {"mode": "eco"},
+                        "kitchen": {"mode": "kitchen"},
+                        "thalposis": {"mode": "thalposis"},
+                        "intelligence": {"mode": "intelligence"},
+                        "unfreeze": {"mode": "unfreeze"},
+                        "wash_bowl": {"mode": "wash_bowl"},
+                        "high_temperature": {"mode": "high_temperature"},
+                        "baby": {"mode": "baby"},
+                        "adult": {"mode": "adult"},
+                        "old": {"mode": "old"}
                    }
                },
                "power_level": {
                    "options": {
-                        "low": {"power_level": "0"},
-                        "medium": {"power_level": "1"},
-                        "high": {"power_level": "2"},
-                        "max": {"power_level": "3"}
+                        "low": {"power_level": 0},
+                        "medium": {"power_level": 1},
+                        "high": {"power_level": 2},
+                        "max": {"power_level": 3}
                    }
                },
                "type_machine": {
                    "options": {
-                        "standard": {"type_machine": "20"},
-                        "premium": {"type_machine": "21"},
-                        "deluxe": {"type_machine": "22"}
+                        "standard": {"type_machine": 20},
+                        "premium": {"type_machine": 21},
+                        "deluxe": {"type_machine": 22}
                    }
                },
                "capacity": {
                    "options": {
-                        "small": {"capacity": "1"},
-                        "medium": {"capacity": "2"},
-                        "large": {"capacity": "3"}
+                        "small": {"capacity": 1},
+                        "medium": {"capacity": 2},
+                        "large": {"capacity": 3}
                    }
                },
-                "gesture_function_type": {
-                    "options": {
-                        "none": {"gesture_function_type": "0"},
-                        "wave": {"gesture_function_type": "1"},
-                        "touch": {"gesture_function_type": "2"},
-                        "proximity": {"gesture_function_type": "3"}
-                    }
-                }
+                # "gesture_function_type": {
+                #     "options": {
+                #         "none": {"gesture_function_type": "0"},
+                #         "wave": {"gesture_function_type": "1"},
+                #         "touch": {"gesture_function_type": "2"},
+                #         "proximity": {"gesture_function_type": "3"}
+                #     }
+                # }
            },
            Platform.SENSOR: {
                "out_water_tem": {
--- a/custom_components/midea_auto_cloud/device_mapping/T0xED.py
+++ b/custom_components/midea_auto_cloud/device_mapping/T0xED.py
@@ -14,9 +14,11 @@ DEVICE_MAPPING = {
                "power": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
-                "heat_start": {
+                "heat": {
+                    "device_class": SwitchDeviceClass.SWITCH,
+                },
+                "antifreeze": {
                    "device_class": SwitchDeviceClass.SWITCH,
-                    "rationale": [0, 1],
                },
                "lock": {
                    "device_class": SwitchDeviceClass.SWITCH,
@@ -111,6 +113,17 @@ DEVICE_MAPPING = {
                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
                    "state_class": SensorStateClass.MEASUREMENT
                },
+                "input_temperature_Sensing": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT,
+                    "translation_key": "input_temperature_sensing"
+                },
+                "hot_pot_temperature": {
+                    "device_class": SensorDeviceClass.TEMPERATURE,
+                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
+                    "state_class": SensorStateClass.MEASUREMENT
+                },
                "cool_target_temperature": {
                    "device_class": SensorDeviceClass.TEMPERATURE,
                    "unit_of_measurement": UnitOfTemperature.CELSIUS,
@@ -137,7 +150,7 @@ DEVICE_MAPPING = {
                    "state_class": SensorStateClass.MEASUREMENT
                },
                "left_salt": {
-                    "device_class": SensorDeviceClass.POWER,
+                    "device_class": SensorDeviceClass.BATTERY,
                    "unit_of_measurement": "%",
                    "state_class": SensorStateClass.MEASUREMENT
                },
@@ -169,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,
@@ -186,6 +199,9 @@ DEVICE_MAPPING = {
                    "unit_of_measurement": UnitOfTime.SECONDS,
                    "state_class": SensorStateClass.MEASUREMENT
                },
+                "heat_start": {
+                    "device_class": SensorDeviceClass.ENUM,
+                },
                "regeneration_stages": {
                    "device_class": SensorDeviceClass.ENUM,
                },
--- 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
@@ -9,19 +9,16 @@ DEVICE_MAPPING = {
        "rationale": ["off", "on"],
        "queries": [{}],
        "centralized": [
-            "power", "disinfect_on_off", "netions_on_off", "airdry_on_off",
+            "power", "disinfect_on_off", "netIons_on_off", "airDry_on_off",
            "wind_gear", "wind_speed", "light_color", "bright_led",
            "humidity_mode", "tank_status", "humidity", "cur_humidity"
        ],
        "entities": {
            Platform.SWITCH: {
-                "disinfect_on_off": {
+                "netIons_on_off": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
-                "netions_on_off": {
-                    "device_class": SwitchDeviceClass.SWITCH,
-                },
-                "airdry_on_off": {
+                "airDry_on_off": {
                    "device_class": SwitchDeviceClass.SWITCH,
                },
                "power": {
@@ -35,9 +32,6 @@ DEVICE_MAPPING = {
                },
                "power_off_timer": {
                    "device_class": SwitchDeviceClass.SWITCH,
-                },
-                "display_on_off": {
-                    "device_class": SwitchDeviceClass.SWITCH,
                }
            },
            Platform.BINARY_SENSOR: {
@@ -56,13 +50,19 @@ DEVICE_MAPPING = {
                    "mode": "humidity_mode",
                    "modes": {
                        "manual": {"humidity_mode": "manual"},
-                        "auto": {"humidity_mode": "auto"},
-                        "sleep": {"humidity_mode": "sleep"},
-                        "baby": {"humidity_mode": "baby"}
+                        "moist_skin": {"humidity_mode": "moist_skin"},
+                        "sleep": {"humidity_mode": "sleep"}
                    }
                }
            },
            Platform.SELECT: {
+                "humidity_mode": {
+                    "options": {
+                        "manual": {"humidity_mode": "manual"},
+                        "moist_skin": {"humidity_mode": "moist_skin"},
+                        "sleep": {"humidity_mode": "sleep"}
+                    }
+                },
                "wind_gear": {
                    "options": {
                        "low": {"wind_gear": "low"},
@@ -77,33 +77,26 @@ DEVICE_MAPPING = {
                        "low": {"wind_speed": "low"},
                        "medium": {"wind_speed": "medium"},
                        "high": {"wind_speed": "high"},
-                        "auto": {"wind_speed": "auto"}
+                        "auto": {"wind_speed": "auto"},
+                        "invalid": {"wind_speed": "invalid"}
                    }
                },
                "light_color": {
                    "options": {
                        "warm": {"light_color": "warm"},
-                        "cool": {"light_color": "cool"},
-                        "white": {"light_color": "white"},
-                        "blue": {"light_color": "blue"},
-                        "green": {"light_color": "green"},
-                        "red": {"light_color": "red"},
+                        #"cool": {"light_color": "cool"},
+                        #"white": {"light_color": "white"},
+                        #"blue": {"light_color": "blue"},
+                        #"green": {"light_color": "green"},
+                        #"red": {"light_color": "red"},
                        "off": {"light_color": "off"}
                    }
                },
                "bright_led": {
                    "options": {
                        "light": {"bright_led": "light"},
-                        "dim": {"bright_led": "dim"},
-                        "off": {"bright_led": "off"}
-                    }
-                },
-                "tank_status": {
-                    "options": {
-                        "normal": {"tank_status": "0"},
-                        "low": {"tank_status": "1"},
-                        "empty": {"tank_status": "2"},
-                        "error": {"tank_status": "3"}
+                        "dark": {"bright_led": "dark"},
+                        "exit": {"bright_led": "exit"}
                    }
                }
            },
@@ -150,8 +143,13 @@ DEVICE_MAPPING = {
                    "device_class": SensorDeviceClass.DURATION,
                    "unit_of_measurement": UnitOfTime.MINUTES,
                    "state_class": SensorStateClass.MEASUREMENT
+                },
+                "tank_status": {
+                    "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
@@ -1,6 +1,6 @@
 from homeassistant.components.humidifier import (
    HumidifierEntity,
-    HumidifierDeviceClass
+    HumidifierDeviceClass, HumidifierEntityFeature
 )
 from homeassistant.const import Platform
 from homeassistant.config_entries import ConfigEntry
@@ -61,6 +61,8 @@ class MideaHumidifierEntity(MideaEntity, HumidifierEntity):
            rationale=rationale,
            config=config,
        )
+        self._attr_supported_features = HumidifierEntityFeature.MODES
+        self._attr_available_modes = list(self._config.get("modes").keys())

    @property
    def device_class(self):
@@ -122,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.6"
+  "version": "v0.1.10"
 }
--- a/custom_components/midea_auto_cloud/translations/en.json
+++ b/custom_components/midea_auto_cloud/translations/en.json
@@ -123,6 +123,9 @@
  },
  "entity": {
    "binary_sensor": {
+      "doorswitch": {
+        "name": "Door Switch"
+      },
      "softener_lack": {
        "name": "Softener Lack"
      },
@@ -145,7 +148,7 @@
        "name": "Bottom Hot"
      },
      "bright_lack": {
-        "name": "Brightness Lack"
+        "name": "Brightener Lack"
      },
      "carpet_switch": {
        "name": "Carpet Switch"
@@ -208,7 +211,7 @@
        "name": "RTC Error"
      },
      "softwater_lack": {
-        "name": "Soft Water Lack"
+        "name": "Lack of Soft Water Salt"
      },
      "storage_door_state": {
        "name": "Storage Door State"
@@ -333,15 +336,40 @@
        "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": {
      "humidifier": {
        "name": "Humidifier"
+      },
+      "dehumidifier": {
+        "name": "Dehumidifier"
      }
    },
    "select": {
@@ -357,6 +385,9 @@
      "control_type": {
        "name": "Control Type"
      },
+      "dehydration_speed": {
+        "name": "Dehydration Speed"
+      },
      "db_dehydration_speed": {
        "name": "DB Dehydration Speed"
      },
@@ -381,6 +412,9 @@
      "db_temperature": {
        "name": "DB Temperature"
      },
+      "water_level": {
+        "name": "Water Level"
+      },
      "db_water_level": {
        "name": "DB Water Level"
      },
@@ -442,21 +476,7 @@
        "name": "Middle Stair Work Status"
      },
      "mode": {
-        "name": "Mode",
-        "options": {
-          "close_all": "Close All",
-          "strong_heating": "Strong Heating",
-          "weak_heating": "Weak Heating",
-          "heating": "Heating",
-          "bath": "Bath",
-          "soft_wind": "Soft Wind",
-          "ventilation": "Ventilation",
-          "morning_ventilation": "Morning Ventilation",
-          "drying": "Drying",
-          "blowing": "Blowing",
-          "drying_safe_power": "Drying Safe Power",
-          "drying_fast": "Drying Fast"
-        }
+        "name": "Mode"
      },
      "mode_state": {
        "name": "Mode State"
@@ -464,9 +484,6 @@
      "mop_status": {
        "name": "Mop Status"
      },
-      "move_direction": {
-        "name": "Move Direction"
-      },
      "power_level": {
        "name": "Power Level"
      },
@@ -503,9 +520,6 @@
      "sterilize": {
        "name": "Sterilize"
      },
-      "sub_work_status": {
-        "name": "Sub Work Status"
-      },
      "tank_status": {
        "name": "Tank Status"
      },
@@ -600,15 +614,7 @@
        "name": "Swing Vertical"
      },
      "left_cookmode": {
-        "name": "Left Cook Mode",
-        "options": {
-          "default": "Default",
-          "order": "Order",
-          "keep_temperature": "Keep Temperature",
-          "local_recipe": "Local Recipe",
-          "cloud_recipe": "Cloud Recipe",
-          "order_keep_temperature": "Order Keep Temperature"
-        }
+        "name": "Left Cook Mode"
      },
      "left_gear": {
        "name": "Left Gear"
@@ -620,22 +626,46 @@
        "name": "Heating Direction"
      },
      "light_mode": {
-        "name": "Light Mode",
-        "options": {
-          "close_all": "Close All",
-          "night_light": "Night Light",
-          "main_light": "Main Light",
-          "all_on": "All On"
-        }
+        "name": "Light Mode"
      },
      "bath_direction": {
        "name": "Bath Direction"
      },
      "drying_direction": {
        "name": "Drying Direction"
+      },
+      "air_set_hour": {
+        "name": "Drying Storage Set Time"
+      },
+      "power_on_time": {
+        "name": "Power On Time"
+      },
+      "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"
+      },
+      "mop": {
+        "name": "Mop Mode"
+      },
+      "move_direction": {
+        "name": "Move Direction"
+      },
+      "sub_work_status": {
+        "name": "Sub Work Status"
+      },
      "mode": {
        "name": "Running Mode"
      },
@@ -646,10 +676,7 @@
        "name": "Air Dry Left Time"
      },
      "air_left_hour": {
-        "name": "AC Remaining Time"
-      },
-      "air_set_hour": {
-        "name": "AC Set Time"
+        "name": "Drying Storage Remaining Time"
      },
      "appointment_time": {
        "name": "Appointment Time"
@@ -679,7 +706,7 @@
        "name": "Bottom Temperature"
      },
      "bright": {
-        "name": "Brightness"
+        "name": "Brightener Level"
      },
      "category": {
        "name": "Category"
@@ -801,9 +828,6 @@
      "db_wash_time": {
        "name": "DB Wash Time"
      },
-      "dehydration_speed": {
-        "name": "Dehydration Speed"
-      },
      "dehydration_time": {
        "name": "Dehydration Time"
      },
@@ -1096,7 +1120,7 @@
        "name": "Softener Global"
      },
      "softwater": {
-        "name": "Soft Water Temp"
+        "name": "Soft Water Level"
      },
      "station_error_desc": {
        "name": "Station Error Description"
@@ -1475,9 +1499,55 @@
      },
      "delay_time": {
        "name": "Delay Time"
+      },
+      "input_temperature_sensing": {
+        "name": "Input Temperature Sensing"
+      },
+      "hot_pot_temperature": {
+        "name": "Hot Pot Temperature"
+      },
+      "water_full_time": {
+        "name": "Water Full Time"
+      },
+      "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": {
+      "screen_close": {
+        "name": "Screen Close"
+      },
+      "anion": {
+        "name": "Anion"
+      },
+      "child_lock": {
+        "name": "Child Lock"
+      },
+      "wind_swing_ud": {
+        "name": "Wind Swing UD"
+      },
+      "filter_tip": {
+        "name": "Filter Tip"
+      },
      "control_status": {
        "name": "Start Pause"
      },
@@ -1665,7 +1735,7 @@
        "name": "Air Dry On Off"
      },
      "airswitch": {
-        "name": "AC Switch"
+        "name": "Drying Storage Switch"
      },
      "appointment": {
        "name": "Appointment"
@@ -1787,9 +1857,6 @@
      "door_warn": {
        "name": "Door Warning"
      },
-      "doorswitch": {
-        "name": "Door Switch"
-      },
      "down_light": {
        "name": "Down Light"
      },
@@ -1970,12 +2037,6 @@
      "power": {
        "name": "Power"
      },
-      "power_off_timer": {
-        "name": "Power Off Timer"
-      },
-      "power_on_timer": {
-        "name": "Power On Timer"
-      },
      "power_state": {
        "name": "Power State"
      },
@@ -2308,7 +2369,25 @@
      },
      "drying_direction": {
        "name": "Drying Direction"
+      },
+      "antifreeze": {
+        "name": "Antifreeze"
+      },
+      "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"
      }
    }
  }
-}
+}
--- a/custom_components/midea_auto_cloud/translations/zh-Hans.json
+++ b/custom_components/midea_auto_cloud/translations/zh-Hans.json
@@ -123,6 +123,9 @@
  },
  "entity": {
    "binary_sensor": {
+      "doorswitch": {
+        "name": "门锁开关"
+      },
      "air_status": {
        "name": "空气运行"
      },
@@ -133,7 +136,7 @@
        "name": "底部加热"
      },
      "bright_lack": {
-        "name": "亮光不足"
+        "name": "亮光剂不足"
      },
      "carpet_switch": {
        "name": "地毯开关"
@@ -196,7 +199,7 @@
        "name": "RTC 错误"
      },
      "softwater_lack": {
-        "name": "软水不足"
+        "name": "软水盐不足"
      },
      "storage_door_state": {
        "name": "冷藏门状态"
@@ -333,15 +336,44 @@
        "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": {
      "humidifier": {
        "name": "加湿器"
+      },
+      "dehumidifier": {
+        "name": "除湿器"
      }
    },
    "select": {
@@ -357,6 +389,9 @@
      "control_type": {
        "name": "控制类型"
      },
+      "dehydration_speed": {
+        "name": "脱水转速"
+      },
      "db_dehydration_speed": {
        "name": "脱水转速"
      },
@@ -381,6 +416,9 @@
      "db_temperature": {
        "name": "温度"
      },
+      "water_level": {
+        "name": "水位"
+      },
      "db_water_level": {
        "name": "水位"
      },
@@ -442,21 +480,7 @@
        "name": "中层工作状态"
      },
      "mode": {
-        "name": "模式",
-        "options": {
-          "close_all": "全部关闭",
-          "strong_heating": "强力加热",
-          "weak_heating": "弱力加热",
-          "heating": "加热",
-          "bath": "浴室",
-          "soft_wind": "柔风",
-          "ventilation": "通风",
-          "morning_ventilation": "晨间通风",
-          "drying": "烘干",
-          "blowing": "吹风",
-          "drying_safe_power": "安全功率烘干",
-          "drying_fast": "快速烘干"
-        }
+        "name": "模式"
      },
      "mode_state": {
        "name": "模式状态"
@@ -464,9 +488,6 @@
      "mop_status": {
        "name": "拖地状态"
      },
-      "move_direction": {
-        "name": "移动方向"
-      },
      "power_level": {
        "name": "功率等级"
      },
@@ -503,9 +524,6 @@
      "sterilize": {
        "name": "杀菌"
      },
-      "sub_work_status": {
-        "name": "子工作状态"
-      },
      "tank_status": {
        "name": "水箱状态"
      },
@@ -600,15 +618,7 @@
        "name": "垂直摆风"
      },
      "left_cookmode": {
-        "name": "左侧烹饪模式",
-        "options": {
-          "default": "默认",
-          "order": "预约",
-          "keep_temperature": "保温",
-          "local_recipe": "本地食谱",
-          "cloud_recipe": "云食谱",
-          "order_keep_temperature": "预约保温"
-        }
+        "name": "左侧烹饪模式"
      },
      "left_gear": {
        "name": "左侧档位"
@@ -620,22 +630,46 @@
        "name": "加热方向"
      },
      "light_mode": {
-        "name": "灯光模式",
-        "options": {
-          "close_all": "全部关闭",
-          "night_light": "夜灯",
-          "main_light": "主灯",
-          "all_on": "全部开启"
-        }
+        "name": "灯光模式"
      },
      "bath_direction": {
        "name": "浴室方向"
      },
      "drying_direction": {
        "name": "烘干方向"
+      },
+      "air_set_hour": {
+        "name": "烘干存储设置时间"
+      },
+      "power_on_time": {
+        "name": "开机时间"
+      },
+      "power_off_time": {
+        "name": "关机时间"
+      },
+      "wind_pressure": {
+        "name": "风压"
      }
    },
    "sensor": {
+      "running_status": {
+        "name": "运行状态"
+      },
+      "tank_status": {
+        "name": "水箱状态"
+      },
+      "fan_level": {
+        "name": "风扇档位"
+      },
+      "mop": {
+        "name": "拖布模式"
+      },
+      "move_direction": {
+        "name": "移动方向"
+      },
+      "sub_work_status": {
+        "name": "子工作状态"
+      },
      "mode": {
        "name": "运行模式"
      },
@@ -646,10 +680,7 @@
        "name": "风干剩余时间"
      },
      "air_left_hour": {
-        "name": "空调剩余时间"
-      },
-      "air_set_hour": {
-        "name": "空调设置时间"
+        "name": "烘干存储剩余时间"
      },
      "appointment_time": {
        "name": "预约时间"
@@ -679,7 +710,7 @@
        "name": "底部温度"
      },
      "bright": {
-        "name": "亮度"
+        "name": "亮光剂档位"
      },
      "category": {
        "name": "类别"
@@ -801,9 +832,6 @@
      "db_wash_time": {
        "name": "洗涤时间"
      },
-      "dehydration_speed": {
-        "name": "脱水转速"
-      },
      "dehydration_time": {
        "name": "脱水时间"
      },
@@ -1096,7 +1124,7 @@
        "name": "柔顺剂全局"
      },
      "softwater": {
-        "name": "软水温度"
+        "name": "软水盐档位"
      },
      "station_error_desc": {
        "name": "基站错误描述"
@@ -1475,9 +1503,55 @@
      },
      "delay_time": {
        "name": "延时时间"
+      },
+      "input_temperature_sensing": {
+        "name": "输入温度"
+      },
+      "hot_pot_temperature": {
+        "name": "热水温度"
+      },
+      "water_full_time": {
+        "name": "满水时间"
+      },
+      "water_full_level": {
+        "name": "满水水位"
+      },
+      "room_temp": {
+        "name": "室内温度"
+      },
+      "cool_temp_set": {
+        "name": "制冷设定温度"
+      },
+      "heat_temp_set": {
+        "name": "制热设定温度"
+      }
+    },
+    "light": {
+      "light": {
+        "name": "电灯"
+      }
+    },
+    "fan": {
+      "fan": {
+        "name": "风扇"
      }
    },
    "switch": {
+      "screen_close": {
+        "name": "屏幕关闭"
+      },
+      "anion": {
+        "name": "负离子"
+      },
+      "child_lock": {
+        "name": "童锁"
+      },
+      "wind_swing_ud": {
+        "name": "上下摆风"
+      },
+      "filter_tip": {
+        "name": "除菌"
+      },
      "add_water_flag": {
        "name": "加水标志"
      },
@@ -1665,7 +1739,7 @@
        "name": "风干开关"
      },
      "airswitch": {
-        "name": "空调开关"
+        "name": "烘干存储开关"
      },
      "appointment": {
        "name": "预约"
@@ -1707,16 +1781,16 @@
        "name": "CO2检测启用"
      },
      "cold_water": {
-        "name": "冷水"
+        "name": "零冷水"
      },
      "cold_water_ai": {
-        "name": "冷水AI"
+        "name": "AI零冷水"
      },
      "cold_water_dot": {
-        "name": "冷水点"
+        "name": "点动零冷水"
      },
      "cold_water_pressure": {
-        "name": "冷水压力"
+        "name": "双增压"
      },
      "comp_state": {
        "name": "压缩机状态"
@@ -1787,9 +1861,6 @@
      "door_warn": {
        "name": "门警告"
      },
-      "doorswitch": {
-        "name": "门锁开关"
-      },
      "down_light": {
        "name": "下灯"
      },
@@ -1812,7 +1883,7 @@
        "name": "烘干通道过热"
      },
      "dryswitch": {
-        "name": "烘干开关"
+        "name": "晶焰烘干开关"
      },
      "easy_ironing": {
        "name": "易熨烫"
@@ -1970,12 +2041,6 @@
      "power": {
        "name": "电源"
      },
-      "power_off_timer": {
-        "name": "关机定时器"
-      },
-      "power_on_timer": {
-        "name": "开机定时器"
-      },
      "power_state": {
        "name": "电源状态"
      },
@@ -2308,6 +2373,24 @@
      },
      "drying_direction": {
        "name": "烘干方向"
+      },
+      "antifreeze": {
+        "name": "防冻模式"
+      },
+      "cold_water_master": {
+        "name": "单次零冷水"
+      },
+      "is_lock_heat": {
+        "name": "制热锁定"
+      },
+      "is_lock_cool": {
+        "name": "制冷锁定"
+      },
+      "fan_speed_lock": {
+        "name": "风速锁定"
+      },
+      "is_lock_rc": {
+        "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	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
sususweet	d49eab91c9	feat: update device mapping for T0xFD by @jesustoachild.	2025-10-10 21:22:14 +08:00
sususweet	ab23b4088e	feat: update translations.	2025-10-10 20:59:00 +08:00
sususweet	c90b8a3d0d	feat: update device mapping for T0xE3.	2025-10-10 20:55:16 +08:00
sususweet	5ffa57bed8	feat: update device mapping for T0xCA.	2025-10-10 20:45:24 +08:00
sususweet	1029b6c4aa	feat: update available_modes for HumidifierEntity	2025-10-10 19:55:30 +08:00
sususweet	6bc49c1b09	feat: update mapping for T0xAC 26093139 device.	2025-10-10 17:01:44 +08:00
sususweet	16460d66ca	feat: version 0.1.8	2025-10-10 10:47:00 +08:00
sususweet	94f0ce84fb	feat: update device mapping for T0xFD. Try to fix #24	2025-10-10 10:45:46 +08:00
sususweet	a2c379a334	feat: add device support for T0xA1	2025-10-10 10:28:59 +08:00
sususweet	2d2d0de10a	fix: update translation and entity for T0xE1	2025-10-10 09:42:51 +08:00
sususweet	2bceda19ac	fix: translation.	2025-10-09 21:11:11 +08:00
sususweet	7ee178b6f2	fix: translation.	2025-10-09 21:09:14 +08:00
sususweet	b45bb48352	Merge remote-tracking branch 'origin/master'	2025-10-09 21:07:40 +08:00
sususweet	cab195f9e0	fix: translation for `input_temperature_Sensing`	2025-10-09 21:07:26 +08:00
sususweet	c92785eea2	Update and rename main.yml to validate.yml	2025-10-09 20:45:37 +08:00
sususweet	dfc6e9c5d3	Merge remote-tracking branch 'origin/master'	2025-10-09 20:39:41 +08:00
sususweet	0072503a00	feat: add mop dry feature for T0xB8.	2025-10-09 20:39:22 +08:00
sususweet	ab146eb54b	Create main.yml	2025-10-09 19:08:29 +08:00
sususweet	51133b94bd	fix: device mapping and translation for T0xCA and T0xED. Fix #23 .	2025-10-09 10:02:08 +08:00
sususweet	7a75376725	Merge pull request #22 from bjzhou/master update device mapping	2025-10-09 09:47:21 +08:00
Hinnka	2c821ceb54	feat: zero cold water switch	2025-10-08 12:43:28 +08:00
Hinnka	2e2ec7a989	feat: update 0xED mapping	2025-10-07 09:03:32 +08:00
hinnka	e1924bdc4b	translations	2025-10-07 08:32:36 +08:00