node-red-contrib-symi-mesh 1.8.0 → 1.8.2

package/README.md

@@ -396,7 +396,7 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
    - **Symi -> HA**：Mesh设备状态变化 -> 更新HA实体状态
    - **HA -> Symi**：HA实体状态变化 -> 控制Mesh设备
 3. **防死循环**：
-   - 内置800ms冷却机制
+   - 内置2秒冷却机制（窗帘30秒）
    - 区分Symi触发和HA触发，避免信号震荡
 4. **便捷配置**：
    - 自动加载所有Symi设备和HA实体
@@ -422,6 +422,87 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
 - **实体类型**：建议同步相同类型的实体（如开关对开关，调光灯对灯光）
 - **多通道设备**：对于多键开关，请分别为每个按键添加一条映射
 
+#### 三合一面板配置
+
+三合一面板（空调+新风+地暖）需要分别配置每个子设备的映射：
+
+1. **选择三合一设备**：在Symi设备下拉框中选择三合一面板
+2. **选择子设备**：在按键选择器中选择要同步的功能：
+   - **空调**：同步开关、温度、模式、风速
+   - **新风**：同步开关、风速
+   - **地暖**：同步开关、温度
+3. **选择HA实体**：
+   - 空调 → climate实体
+   - 新风 → fan实体
+   - 地暖 → climate实体
+
+**示例配置**：
+```
+三合一面板_xxx [空调] ↔ climate.living_room_ac
+三合一面板_xxx [新风] ↔ fan.living_room_fresh_air
+三合一面板_xxx [地暖] ↔ climate.living_room_floor_heating
+```
+
+#### 窗帘同步说明
+
+窗帘设备采用特殊的同步机制，避免运动过程中的步进反馈干扰：
+
+- **30秒防死循环窗口**：窗帘运动时间较长，使用30秒防死循环（普通设备2秒）
+- **1.5秒防抖**：等待窗帘位置稳定后再同步，避免步进码干扰
+- **运动状态跟踪**：记录运动发起方（Symi/HA），忽略对方的中间状态反馈
+- **opening/closing过滤**：HA窗帘处于运动状态时，不同步位置变化到Mesh
+
+
+### MQTT品牌同步
+
+Symi MQTT同步节点 (`symi-mqtt-sync`) 用于实现第三方MQTT品牌设备与Symi Mesh设备的双向状态同步。
+
+#### 功能特性
+
+1. **双MQTT配置**：
+   - Mesh MQTT：连接Symi网关获取设备列表
+   - 品牌MQTT：连接第三方品牌MQTT服务器
+2. **设备自动发现**：品牌MQTT连接后自动发现设备
+3. **双向同步**：品牌设备↔Mesh设备实时状态同步
+4. **配置持久化**：设备列表和映射配置持久保存，断线后仍可显示
+
+#### 支持的品牌协议
+
+| 品牌 | 设备类型 | 功能码映射 |
+|------|---------|-----------|
+| HYQW（花语前湾） | 灯具(8) | 开关(fn=1)、亮度(fn=2, 0-100) |
+| | 空调(12) | 开关(fn=1)、温度(fn=2, 18-29°C)、模式(fn=3)、风速(fn=4) |
+| | 窗帘(14) | 动作(fn=1, 开/关/停)、位置(fn=2, 0-100%) |
+| | 地暖(16) | 开关(fn=1)、温度(fn=2, 5-35°C) |
+| | 新风(36) | 开关(fn=1)、风速(fn=3) |
+
+#### 配置步骤
+
+1. **添加品牌MQTT配置节点**：
+   - 从左侧拖入`Symi MQTT Brand`配置节点
+   - 配置品牌MQTT服务器地址、用户名、密码
+   - 选择品牌协议（如HYQW）
+
+2. **添加MQTT同步节点**：
+   - 从左侧拖入`Symi MQTT Sync`节点
+   - 选择Mesh MQTT配置（用于获取Mesh设备）
+   - 选择品牌MQTT配置（用于获取品牌设备）
+
+3. **配置实体映射**：
+   - 点击"添加"按钮
+   - 左侧选择Mesh设备（多路开关可选择按键）
+   - 右侧选择品牌设备
+   - 可添加多组映射
+
+4. **部署**：点击部署，开始双向同步
+
+#### 注意事项
+
+- **设备类型匹配**：建议同步相同类型的设备（灯具对灯具，空调对空调）
+- **离线设备显示**：[离线]标记缓存中但当前不在线的设备
+- **防死循环**：内置2秒防抖机制，避免状态震荡
+- **自动重连**：5秒重连间隔，断线自动恢复
+
 
 ## 协议说明
 
@@ -1332,8 +1413,8 @@ A: 每个房间部署一个云端同步节点，配置对应的酒店ID和房间
 | **Symi KNX Bridge** | KNX系统双向同步 | [KNX双向同步](#knx双向同步) |
 | **Symi KNX-HA Bridge** | KNX与HA实体双向同步 | [KNX-HA双向同步](#knx-ha双向同步) |
 | **Symi HA Sync** | HA实体双向同步 | [HA双向同步](#ha双向同步) |
-| **Symi MQTT Sync** | 第三方MQTT品牌设备同步 | v1.7.3新增 |
-| **Symi MQTT Brand** | 品牌MQTT配置节点 | v1.7.3新增 |
+| **Symi MQTT Sync** | 第三方MQTT品牌设备同步 | [MQTT品牌同步](#mqtt品牌同步) |
+| **Symi MQTT Brand** | 品牌MQTT配置节点 | [MQTT品牌同步](#mqtt品牌同步) |
 | **RS485 Debug** | RS485总线数据抓包调试 | [RS485调试节点](#rs485调试节点) |
 | **Symi RS485 Sync** | 两种RS485协议双向同步 | [RS485协议同步](#rs485协议同步) |
 
@@ -1503,6 +1584,36 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.2 (2026-01-05)
+- **MQTT品牌同步协议修复**：
+  - **窗帘设备协议修复**：修复窗帘fn=1功能码的正确解析（0=关闭, 1=打开, 2=停止），之前错误地当作开关处理
+  - **设备类型独立处理**：重构syncToMesh和syncToMqtt函数，按设备类型(8/12/14/16/36)独立处理功能码映射
+  - **完整功能码支持**：
+    - 灯具(8): fn=1开关, fn=2亮度
+    - 空调(12): fn=1开关, fn=2温度, fn=3模式, fn=4风速
+    - 窗帘(14): fn=1动作(开/关/停), fn=2位置
+    - 地暖(16): fn=1开关, fn=2温度
+    - 新风(36): fn=1开关, fn=3风速
+  - **错误日志增强**：同步失败时输出详细错误信息，便于调试
+
+### v1.8.1 (2026-01-05)
+- **三合一面板深度集成**：
+  - **子设备选择**：HA同步节点新增三合一子设备选择功能，可分别选择“空调”、“新风”、“地暖”进行独立映射。
+  - **完整属性同步**：支持空调（开关/模式/温度/风速）、新风（开关/风速）、地暖（开关/温度）的全功能双向同步。
+- **配置与文档优化**：
+  - **纯配置同步**：明确HA同步节点为纯配置模式，无需额外连线即可实现双向同步。
+  - **文档更新**：全面更新README，增加三合一配置示例和Config-Only说明。
+- **稳定性修复**：
+  - 修复 Symi→HA 同步时的调试日志重复输出问题。
+  - 增强 HA 事件监听的健壮性，支持多种输入格式。
+- **窗帘双向同步修复**：
+  - **运动状态跟踪**：新增 `coverMoving` 状态跟踪机制，记录窗帘运动的发起方（Symi/HA）和开始时间
+  - **步进反馈过滤**：当 HA 发起窗帘控制时，自动忽略 Mesh 窗帘运动过程中的步进位置反馈，避免干扰
+  - **运动中状态过滤**：当 HA 窗帘处于 `opening`/`closing` 状态时，不同步位置变化到 Mesh，只同步最终位置
+  - **专用防死循环时间**：窗帘使用 30 秒防死循环窗口（普通设备 2 秒），适应窗帘较长的运动时间
+  - **防抖时间优化**：窗帘防抖时间从 500ms 增加到 1500ms，确保位置稳定后再同步
+  - **自动清理机制**：运动状态超时（30秒）自动清理，防止内存泄漏
+
 ### v1.8.0 (2026-01-05)
 - **HA同步节点重大增强**：
   - **同步模式选择**：新增“双向同步”、“仅Symi→HA”、“仅HA→Symi”三种模式，配置更加灵活。
@@ -1571,80 +1682,6 @@ node-red-contrib-symi-mesh/
   - 完善的节点关闭清理逻辑
   - 防死循环机制增强：双向时间戳检查
 
-### v1.7.7 (2026-01-05)
-- **RS485桥接节点逻辑优化**：
-  - 修复自定义码模式下"反馈"按钮点击部署后依旧开启的问题
-  - 完善 `oneditsave` 逻辑，确保反馈选项状态被持久化保存
-  - **防循环优化**：优化 `loopKey` 生成逻辑，加入 `meshChannel` 字段，支持多通道设备独立防循环，解决多路开关干扰问题
-  - **冷却时间调整**：将防死循环冷却时间从 500ms 延长至 800ms，提高复杂网络环境下的同步稳定性
-  - **反馈逻辑细化**：严格执行"反馈"勾选逻辑，未勾选时禁止回环发送自定义码到总线
-  - **调试增强**：增加自定义码匹配成功的详细日志（包含设备 MAC 和具体动作）
-
-### v1.7.5 (2025-12-24)
-- **RS485双向同步节点**：新增`symi-rs485-sync`独立节点实现两种不同RS485协议之间的双向同步
-  - 支持中弘VRF网关协议（功能码0x31-0x34控制，0x50查询）
-  - 支持SYMI空调面板Modbus协议
-  - 支持自定义码协议
-  - 双向状态同步，2秒防抖防止死循环
-  - 多组映射配置，持久化保存
-  - **反馈选项**：新增"反馈"复选框，控制RS485收码后是否发送反馈码
-  - **Mesh→RS485方向**：
-    - 修复开关控制：只同步配置的通道，避免其他通道变化误触发
-    - 修复空调风速：fanMode变化正确发送fanSendHigh/Mid/Low/Auto码
-    - 修复空调中速(fanMode=2)事件触发
-    - 修复空调开关：去重处理，避免switch和acSwitch重复发送
-    - 添加自动风速(fanSendAuto/fanRecvAuto)配置支持
-  - **RS485→Mesh方向**：
-    - 修复收码匹配触发Mesh实体状态变化
-    - 自定义开关recvOn/recvOff正确触发开关动作
-    - 自定义空调acRecvOn/acRecvOff/fanRecvHigh等正确触发空调控制
-  - **事件系统优化**：
-    - DeviceManager事件添加完整字段（isUserControl、isSceneExecution等）
-    - 用户控制事件允许绕过首次状态缓存
-    - 修复单路温控器开关事件丢失问题
-    - fanMode事件同时发送acFanSpeed别名字段
-  - **防死循环优化**：
-    - 使用映射特定时间戳，避免不同设备同步互相影响
-    - Mesh→RS485和RS485→Mesh双向都记录同步时间
-    - 500ms冷却时间防止状态回环
-    - 空调命令去重（同类命令只发送一次）
-  - **生产稳定性**：
-    - 初始化延迟从10秒缩短为5秒
-    - 详细日志改为debug级别，减少生产环境日志量
-    - 保留关键同步日志便于问题排查
-  - **UI优化**：
-    - 自定义码折叠按钮移到同一行，减少占用空间
-    - 修复MAC地址大小写匹配问题
-    - 添加自动风速配置框（发自动/收自动）
-- **RS485-to-RS485空调桥接**：SYMI空调面板与中弘VRF系统双向同步
-  - 支持SYMI 485空调面板协议（7E...7D帧格式，CRC8校验）
-  - 支持中弘VRF空调协议（求和校验，功能码0x31-0x34控制，0x50查询）
-  - 双向状态同步：SYMI面板操作→中弘VRF执行，中弘状态→SYMI面板显示
-
-### v1.7.1 (2025-12-21)
-- **自定义协议全面修复**：完善自定义开关/窗帘/空调双向同步
-  - **空调风速控制**：修复风速变化事件触发机制
-    - 添加fanMode字段支持（mesh空调实际使用的字段）
-    - 修复DeviceInfo事件触发，正确发送device-state-changed事件
-    - 支持风速值1-4（1=高, 2=中, 3=低, 4=自动）
-    - 自动识别温控器0x02消息中的风速控制
-  - **空调开关控制**：修复开关状态变化事件触发
-    - 温控器0x02开关消息正确触发device-state-changed事件
-    - 自定义空调开关码（acSendOn/acSendOff）正确发送到RS485总线
-  - **RS485收码匹配**：修复hexStr格式处理
-    - hexStr完全去掉空格，确保标准格式（如030610330001BD27）
-    - 用户录入支持带空格格式（如01 06 10 34 00 01 0D 04）
-    - 自动匹配并触发mesh实体动作
-  - **事件系统优化**：
-    - DeviceInfo添加manager引用，正确触发事件
-    - 修复事件名称不匹配问题（stateChange -> device-state-changed）
-    - 确保所有自定义码双向同步正常
-  - **队列处理**：
-    - 命令队列顺序处理，防止并发冲突
-    - 500ms防死循环机制
-    - 队列限制100条，防止内存溢出
-  - **调试日志**：添加详细调试日志，方便排查问题
-
 ## 许可证
 
 MIT License
@@ -1656,7 +1693,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.7.9
+**版本**: 1.8.2
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2026-01-05
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

package/nodes/symi-ha-sync.html

@@ -119,6 +119,12 @@
             // 判断是否需要按键选择
             function needsKeySelection(device, savedChannels, savedEntityType) {
                 var entityType = (device ? device.entityType : savedEntityType) || '';
+                
+                // 三合一面板必须选择子设备
+                if (entityType === 'three_in_one') {
+                    return true;
+                }
+                
                 // 如果是温控器、窗帘、灯具，不需要选择按键（通常是单路或特殊处理）
                 if (entityType === 'climate' || entityType === 'cover' || entityType === 'light') {
                     return false;
@@ -132,6 +138,7 @@
             function getDeviceTypeLabel(device) {
                 if (!device) return '';
                 var entityType = device.entityType || '';
+                if (entityType === 'three_in_one') return ' [三合一]';
                 if (entityType === 'climate') return ' [温控器]';
                 if (entityType === 'cover') return ' [窗帘]';
                 if (entityType === 'light') return ' [灯具]';
@@ -177,14 +184,31 @@
                     }
                 });
                 
+                var entityType = (device ? device.entityType : savedEntityType) || '';
                 if (!needsKeySelection(device, savedChannels, savedEntityType)) return '';
                 
-                var channels = device ? (device.channels || 1) : (savedChannels || 1);
                 var html = '<select class="symi-key">';
-                for (var i = 1; i <= channels; i++) {
-                    var sel = (i == selectedKey) ? ' selected' : '';
-                    html += '<option value="' + i + '"' + sel + '>按键' + i + '</option>';
+                
+                // 三合一设备特殊处理
+                if (entityType === 'three_in_one') {
+                    var opts = [
+                        {v: 'aircon', l: '空调'},
+                        {v: 'fresh_air', l: '新风'},
+                        {v: 'floor_heating', l: '地暖'}
+                    ];
+                    opts.forEach(function(o) {
+                        var sel = (o.v == selectedKey) ? ' selected' : '';
+                        html += '<option value="' + o.v + '"' + sel + '>' + o.l + '</option>';
+                    });
+                } else {
+                    // 多路开关
+                    var channels = parseInt(device ? (device.channels || 1) : (savedChannels || 1)) || 1;
+                    for (var i = 1; i <= channels; i++) {
+                        var sel = (i == selectedKey) ? ' selected' : '';
+                        html += '<option value="' + i + '"' + sel + '>按键' + i + '</option>';
+                    }
                 }
+                
                 html += '</select>';
                 return html;
             }
@@ -337,6 +361,8 @@
                     haEntityId: '', haEntityName: ''
                 });
                 renderMappings();
+                var list = $('#mapping-list');
+                list.scrollTop(list.prop('scrollHeight'));
             });
 
             // 配置变化时重新加载

package/nodes/symi-ha-sync.js

@@ -1,6 +1,6 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.0
+ * 版本: 1.8.2
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -15,10 +15,17 @@ module.exports = function(RED) {
     
     // 常量定义
     const LOOP_PREVENTION_MS = 2000;  // 防死循环时间窗口
-    const DEBOUNCE_MS = 500;          // 防抖时间（窗帘/调光用）
+    const DEBOUNCE_MS = 500;          // 通用防抖时间
     const MAX_QUEUE_SIZE = 100;
     const CLEANUP_INTERVAL_MS = 60000;
     const TIMESTAMP_EXPIRE_MS = 60000;
+    
+    // 窗帘专用常量
+    const COVER_LOOP_PREVENTION_MS = 30000; // 30秒防死循环
+    const COVER_DEBOUNCE_MS = 1500;         // 1.5秒防抖
+    
+    // 调光专用常量
+    const BRIGHTNESS_DEBOUNCE_MS = 800;     // 0.8秒防抖，过滤步进过程
 
     // Mesh属性类型
     const ATTR_SWITCH = 0x02;
@@ -28,6 +35,14 @@ module.exports = function(RED) {
     const ATTR_TARGET_TEMP = 0x1B;
     const ATTR_FAN_MODE = 0x1C;
     const ATTR_CLIMATE_MODE = 0x1D;
+    
+    // 三合一属性
+    const ATTR_FRESH_AIR_SWITCH = 0x68;
+    const ATTR_FRESH_AIR_MODE = 0x69;
+    const ATTR_FRESH_AIR_SPEED = 0x6A;
+    const ATTR_FLOOR_HEATING_SWITCH = 0x6B;
+    const ATTR_FLOOR_HEATING_TEMP = 0x6C;
+    const ATTR_THREE_IN_ONE = 0x94;
 
     // 空调模式映射
     const AC_MODE_TO_HA = { 1: 'cool', 2: 'heat', 3: 'fan_only', 4: 'dry' };
@@ -48,15 +63,23 @@ module.exports = function(RED) {
         // 解析映射配置
         try {
             const rawMappings = JSON.parse(config.mappings || '[]');
-            node.mappings = rawMappings.map(m => ({
-                symiMac: m.symiMac,
-                symiKey: parseInt(m.symiKey) || 1,
-                haEntityId: m.haEntityId,
-                symiName: m.symiName || '',
-                haEntityName: m.haEntityName || '',
-                symiEntityType: m.symiEntityType || '',
-                syncMode: parseInt(m.syncMode) || 0
-            })).filter(m => m.symiMac && m.haEntityId);
+            node.mappings = rawMappings.map(m => {
+                // symiKey可能是数字（按键索引）或字符串（三合一子设备ID）
+                let key = m.symiKey;
+                if (typeof key !== 'string' || !isNaN(parseInt(key))) {
+                    key = parseInt(key) || 1;
+                }
+                
+                return {
+                    symiMac: m.symiMac,
+                    symiKey: key,
+                    haEntityId: m.haEntityId,
+                    symiName: m.symiName || '',
+                    haEntityName: m.haEntityName || '',
+                    symiEntityType: m.symiEntityType || '',
+                    syncMode: parseInt(m.syncMode) || 0
+                };
+            }).filter(m => m.symiMac && m.haEntityId);
             
             if (node.mappings.length > 0) {
                 node.log(`[HA同步] 已加载 ${node.mappings.length} 个映射`);
@@ -71,6 +94,8 @@ module.exports = function(RED) {
         node.lastSymiToHa = {};
         node.lastHaToSymi = {};
         node.pendingDebounce = {};  // 防抖定时器
+        node.coverMoving = {};      // 窗帘运动状态跟踪 { loopKey: { direction: 'symi'|'ha', startTime, targetPosition } }
+        node.brightnessMoving = {}; // 调光运动状态跟踪 { loopKey: { direction: 'ha', startTime } }
         
         node.status({ fill: 'yellow', shape: 'ring', text: '初始化中' });
 
@@ -106,6 +131,20 @@ module.exports = function(RED) {
                     delete node.lastHaToSymi[key];
                 }
             }
+            
+            // 清理过期的窗帘运动状态
+            for (const key in node.coverMoving) {
+                if (now - node.coverMoving[key].startTime > COVER_LOOP_PREVENTION_MS) {
+                    delete node.coverMoving[key];
+                }
+            }
+            
+            // 清理过期的调光运动状态
+            for (const key in node.brightnessMoving) {
+                if (now - node.brightnessMoving[key].startTime > LOOP_PREVENTION_MS) {
+                    delete node.brightnessMoving[key];
+                }
+            }
         }, CLEANUP_INTERVAL_MS);
 
         // 防死循环检查 - 双向时间戳检查
@@ -212,24 +251,116 @@ module.exports = function(RED) {
                             syncData = node.handleClimateModeChange(device, mapping, state);
                         }
                         break;
+
+                    case ATTR_THREE_IN_ONE: // 0x94 三合一全量状态
+                    case ATTR_FRESH_AIR_SWITCH: // 0x68 新风开关
+                    case ATTR_FRESH_AIR_MODE: // 0x69 新风模式
+                    case ATTR_FRESH_AIR_SPEED: // 0x6A 新风风速
+                    case ATTR_FLOOR_HEATING_SWITCH: // 0x6B 地暖开关
+                    case ATTR_FLOOR_HEATING_TEMP: // 0x6C 地暖温度
+                        syncData = node.handleThreeInOneChange(device, mapping, state, attrType);
+                        break;
                 }
                 
                 if (syncData) {
-                    if (node.shouldPreventSync('symi-to-ha', loopKey)) {
-                        node.debug(`[Symi->HA] 跳过(防死循环): ${loopKey}`);
-                        return;
-                    }
+                    // 支持返回数组（用于三合一同时同步多个属性）
+                    const syncDataList = Array.isArray(syncData) ? syncData : [syncData];
                     
-                    node.queueCommand({
-                        direction: 'symi-to-ha',
-                        mapping: mapping,
-                        syncData: syncData,
-                        key: loopKey
+                    syncDataList.forEach(data => {
+                        if (node.shouldPreventSync('symi-to-ha', loopKey)) {
+                            node.debug(`[Symi->HA] 跳过(防死循环): ${loopKey} ${data.type}`);
+                            return;
+                        }
+                        
+                        node.queueCommand({
+                            direction: 'symi-to-ha',
+                            mapping: mapping,
+                            syncData: data,
+                            key: loopKey
+                        });
                     });
                 }
             });
         };
 
+        // 处理三合一状态变化
+        node.handleThreeInOneChange = function(device, mapping, state, attrType) {
+            const subType = mapping.symiKey; // 'aircon', 'fresh_air', 'floor_heating'
+            
+            // 1. 空调部分 (通常通过0x94或标准温控指令更新)
+            if (subType === 'aircon') {
+                // 如果是标准温控属性更新，已经在switch case中处理了
+                // 这里主要处理0x94带来的全量更新
+                if (attrType === ATTR_THREE_IN_ONE) {
+                    // 此时state已经包含了所有更新
+                    // 需要检查哪些属性变了，但这里只能返回一个syncData
+                    // 我们可以返回一个特殊对象，或者分别检查
+                    // 为简化，这里假设HA端会处理部分更新，或者我们按优先级返回
+                    
+                    // 检查开关
+                    if (state.climateSwitch !== undefined) {
+                         // 注意：这里需要比对旧状态，但在handleSymiStateChange中难以获取旧状态
+                         // 我们可以利用node.queueCommand的去重机制，发送所有可能的状态
+                         // 但这样会产生大量流量。
+                         // 实际上DeviceManager触发事件时，如果是0x94，是全量更新。
+                         // 我们可以只处理核心属性。
+                         // 更好的方式是：在device-manager中，0x94更新会触发一次事件。
+                         // 这里我们返回一个复合对象，或者由上层逻辑拆分。
+                         // 由于syncData只能是一个对象，我们优先同步开关，然后是模式/温度
+                    }
+                }
+                // 由于0x94更新时，device-manager已经更新了state
+                // 我们可以直接从state读取当前值
+                
+                // 构造空调状态
+                // 这里我们可能需要多次调用queueCommand，但handle函数只能返回一个
+                // 解决方案：handleSymiStateChange支持返回数组
+                return [
+                    { type: 'switch', value: state.climateSwitch },
+                    { type: 'temperature', value: state.targetTemp },
+                    { type: 'hvac_mode', value: AC_MODE_TO_HA[state.climateMode] || 'off', meshValue: state.climateMode },
+                    { type: 'fan_mode', value: FAN_MODE_TO_HA[state.fanMode] || 'auto', meshValue: state.fanMode }
+                ];
+            }
+            
+            // 2. 新风部分
+            if (subType === 'fresh_air') {
+                // 新风开关 (0x68或0x94)
+                if (attrType === ATTR_FRESH_AIR_SWITCH || attrType === ATTR_THREE_IN_ONE) {
+                    if (state.freshAirSwitch !== undefined) {
+                        return { type: 'switch', value: state.freshAirSwitch };
+                    }
+                }
+                // 新风风速 (0x6A或0x94)
+                if (attrType === ATTR_FRESH_AIR_SPEED || attrType === ATTR_THREE_IN_ONE) {
+                    if (state.freshAirSpeed !== undefined) {
+                        return { type: 'fan_mode', value: FAN_MODE_TO_HA[state.freshAirSpeed] || 'auto', meshValue: state.freshAirSpeed };
+                    }
+                }
+                // 新风模式 (0x69或0x94)
+                // 目前HA Fan实体通常只支持on/off和speed，mode可能不支持或映射到preset_mode
+                // 暂时忽略模式，或视需求添加
+            }
+            
+            // 3. 地暖部分
+            if (subType === 'floor_heating') {
+                // 地暖开关 (0x6B或0x94)
+                if (attrType === ATTR_FLOOR_HEATING_SWITCH || attrType === ATTR_THREE_IN_ONE) {
+                    if (state.floorHeatingSwitch !== undefined) {
+                        return { type: 'switch', value: state.floorHeatingSwitch };
+                    }
+                }
+                // 地暖温度 (0x6C或0x94)
+                if (attrType === ATTR_FLOOR_HEATING_TEMP || attrType === ATTR_THREE_IN_ONE) {
+                    if (state.floorHeatingTemp !== undefined) {
+                        return { type: 'temperature', value: state.floorHeatingTemp };
+                    }
+                }
+            }
+            
+            return null;
+        };
+
         // 处理开关状态变化
         node.handleSwitchChange = function(device, mapping, state) {
             let isOn = false;
@@ -247,21 +378,67 @@ module.exports = function(RED) {
             return { type: 'switch', value: isOn };
         };
 
-        // 处理亮度变化
+        // 处理亮度变化（带防抖，避免步进过程干扰）
         node.handleBrightnessChange = function(device, mapping, state) {
             const brightness = state.brightness !== undefined ? state.brightness : device.state.brightness;
             if (brightness === undefined) return null;
             
+            const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+            
+            // 检查是否是HA发起的调光，如果是则忽略Mesh的亮度反馈（步进码）
+            if (node.brightnessMoving && node.brightnessMoving[loopKey]) {
+                const elapsed = Date.now() - node.brightnessMoving[loopKey].startTime;
+                if (elapsed < LOOP_PREVENTION_MS) {
+                    node.debug(`[Symi->HA] 亮度忽略(HA发起调光中): ${loopKey}`);
+                    return null;
+                } else {
+                    delete node.brightnessMoving[loopKey];
+                }
+            }
+            
+            // 防抖处理：取消之前的定时器，设置新的
+            const debounceKey = `brightness_${mapping.symiMac}_${mapping.symiKey}`;
+            if (node.pendingDebounce[debounceKey]) {
+                clearTimeout(node.pendingDebounce[debounceKey]);
+            }
+            
             // Mesh亮度0-100，HA亮度0-255
             const haBrightness = Math.round(brightness * 255 / 100);
-            return { type: 'brightness', value: haBrightness, meshValue: brightness };
+            
+            // 延迟同步，等待亮度稳定（过滤步进过程）
+            node.pendingDebounce[debounceKey] = setTimeout(() => {
+                delete node.pendingDebounce[debounceKey];
+                
+                node.queueCommand({
+                    direction: 'symi-to-ha',
+                    mapping: mapping,
+                    syncData: { type: 'brightness', value: haBrightness, meshValue: brightness },
+                    key: loopKey,
+                    skipLoopCheck: true
+                });
+            }, BRIGHTNESS_DEBOUNCE_MS);
+            
+            return null;  // 不立即同步，由定时器处理
         };
 
-        // 处理窗帘变化（带防抖）
+        // 处理窗帘变化（带防抖，避免步进反馈干扰）
         node.handleCurtainChange = function(device, mapping, state, attrType) {
             const domain = node.getEntityDomain(mapping.haEntityId);
             if (domain !== 'cover') return null;
             
+            const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+            
+            // 检查是否是HA发起的运动，如果是则忽略Mesh的位置反馈（步进码）
+            if (node.coverMoving[loopKey] && node.coverMoving[loopKey].direction === 'ha') {
+                const elapsed = Date.now() - node.coverMoving[loopKey].startTime;
+                if (elapsed < COVER_LOOP_PREVENTION_MS) {
+                    node.debug(`[Symi->HA] 窗帘忽略(HA发起运动中): ${loopKey}`);
+                    return null;  // 忽略HA发起运动期间的Mesh反馈
+                } else {
+                    delete node.coverMoving[loopKey];  // 超时清理
+                }
+            }
+            
             // 窗帘位置变化 - 使用防抖，只同步最终位置
             if (attrType === ATTR_CURTAIN_POSITION) {
                 const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
@@ -273,27 +450,34 @@ module.exports = function(RED) {
                     clearTimeout(node.pendingDebounce[debounceKey]);
                 }
                 
+                // 标记Symi发起的运动
+                node.coverMoving[loopKey] = { direction: 'symi', startTime: Date.now(), targetPosition: position };
+                
                 // 延迟同步，等待位置稳定
                 node.pendingDebounce[debounceKey] = setTimeout(() => {
                     delete node.pendingDebounce[debounceKey];
-                    const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
-                    if (!node.shouldPreventSync('symi-to-ha', loopKey)) {
-                        node.queueCommand({
-                            direction: 'symi-to-ha',
-                            mapping: mapping,
-                            syncData: { type: 'position', value: position },
-                            key: loopKey
-                        });
-                    }
-                }, DEBOUNCE_MS);
+                    // 运动结束，清理状态
+                    delete node.coverMoving[loopKey];
+                    
+                    // 直接入队，跳过常规防死循环检查（窗帘有专门的运动状态跟踪）
+                    node.queueCommand({
+                        direction: 'symi-to-ha',
+                        mapping: mapping,
+                        syncData: { type: 'position', value: position },
+                        key: loopKey,
+                        skipLoopCheck: true
+                    });
+                }, COVER_DEBOUNCE_MS);
                 
                 return null;  // 不立即同步
             }
             
-            // 窗帘运行状态 - 可选同步动作
+            // 窗帘运行状态 - 同步停止动作
             if (attrType === ATTR_CURTAIN_STATUS) {
                 const action = state.curtainAction || device.state.curtainAction;
                 if (action === 'stopped') {
+                    // 停止时清理运动状态
+                    delete node.coverMoving[loopKey];
                     return { type: 'curtain_stop' };
                 }
             }
@@ -333,21 +517,61 @@ module.exports = function(RED) {
         
         // 方式A: 通过Input输入 (server-state-changed节点)
         node.on('input', function(msg) {
-            if (msg.data && msg.data.entity_id && msg.data.new_state) {
+            if (msg.payload && (msg.payload.entity_id || (msg.data && msg.data.entity_id))) {
+                const entityId = msg.payload.entity_id || msg.data.entity_id;
+                const newState = msg.payload.new_state || msg.data.new_state;
+                const oldState = msg.payload.old_state || msg.data.old_state;
+                
+                if (entityId && newState) {
+                    node.handleHaStateChange(entityId, newState, oldState);
+                }
+            } else if (msg.data && msg.data.entity_id && msg.data.new_state) {
+                // 兼容旧格式
                 node.handleHaStateChange(msg.data.entity_id, msg.data.new_state, msg.data.old_state);
             }
         });
         
-        // 方式B: 尝试订阅HA Server事件总线
-        if (node.haServer && node.haServer.eventBus) {
-            node.haEventHandler = (evt) => {
-                if (evt && evt.event_type === 'state_changed' && evt.data) {
-                    node.handleHaStateChange(evt.data.entity_id, evt.data.new_state, evt.data.old_state);
+        // 方式B: 尝试订阅HA Server事件总线 (静默订阅机制)
+        const subscribeToHaEvents = () => {
+            if (!node.haServer) {
+                return;
+            }
+
+            // node-red-contrib-home-assistant-websocket 不同版本可能暴露不同的事件总线
+            let eventBus = node.haServer.eventBus;
+            if (!eventBus && node.haServer.controller) {
+                eventBus = node.haServer.controller.events;
+            }
+
+            if (eventBus) {
+                // 防止重复订阅
+                if (node.haSubscribed) return;
+
+                node.haEventHandler = (evt) => {
+                    if (evt && evt.event_type === 'state_changed' && evt.data) {
+                        node.handleHaStateChange(evt.data.entity_id, evt.data.new_state, evt.data.old_state);
+                    }
+                };
+                eventBus.on('ha_events:all', node.haEventHandler);
+                node.haSubscribed = true;
+                node.log('[HA同步] 已成功订阅HA事件总线');
+                node.status({ fill: 'green', shape: 'dot', text: '已连接' });
+            } else {
+                // 静默重试，不打印 info 日志，只在后台运行
+                node.haSubscribedRetryCount = (node.haSubscribedRetryCount || 0) + 1;
+                
+                // 每 5 秒检查一次，直到成功为止（不设上限，因为这是后台静默检查）
+                // 只有在前 3 次且是 debug 模式下才打印
+                if (node.haSubscribedRetryCount <= 3) {
+                    node.debug(`[HA同步] 等待 HA 事件总线就绪... (${node.haSubscribedRetryCount})`);
                 }
-            };
-            node.haServer.eventBus.on('ha_events:all', node.haEventHandler);
-            node.log('[HA同步] 已订阅HA事件总线');
-        }
+                
+                setTimeout(subscribeToHaEvents, 5000);
+            }
+        };
+        
+        // 启动后立即开始静默尝试
+        subscribeToHaEvents();
 
         node.handleHaStateChange = function(entityId, newState, oldState) {
             if (!newState) return;
@@ -393,23 +617,51 @@ module.exports = function(RED) {
                             if (!oldState || oldAttrs.brightness !== attrs.brightness) {
                                 // HA亮度0-255，Mesh亮度0-100
                                 const meshBrightness = Math.round(attrs.brightness * 100 / 255);
+                                // 标记HA发起的调光，防止Mesh步进反馈回传
+                                node.brightnessMoving[loopKey] = { direction: 'ha', startTime: Date.now() };
                                 syncDataList.push({ type: 'brightness', value: meshBrightness });
                             }
                         }
                         break;
                         
                     case 'cover':
-                        // 窗帘位置
+                        const coverLoopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                        
+                        // 检查是否是Symi发起的运动，如果是则忽略HA的位置反馈
+                        if (node.coverMoving[coverLoopKey] && node.coverMoving[coverLoopKey].direction === 'symi') {
+                            const elapsed = Date.now() - node.coverMoving[coverLoopKey].startTime;
+                            if (elapsed < COVER_LOOP_PREVENTION_MS) {
+                                node.debug(`[HA->Symi] 窗帘忽略(Symi发起运动中): ${coverLoopKey}`);
+                                break;  // 忽略Symi发起运动期间的HA反馈
+                            }
+                        }
+                        
+                        // 运动中状态(opening/closing)不同步位置，避免步进反馈干扰
+                        if (newState.state === 'opening' || newState.state === 'closing') {
+                            node.debug(`[HA->Symi] 窗帘运动中，跳过位置同步: ${newState.state}`);
+                            break;
+                        }
+                        
+                        // 窗帘位置变化 - 只在停止状态时同步
                         if (attrs.current_position !== undefined) {
                             if (!oldState || oldAttrs.current_position !== attrs.current_position) {
+                                // 标记HA发起的运动
+                                node.coverMoving[coverLoopKey] = { 
+                                    direction: 'ha', 
+                                    startTime: Date.now(), 
+                                    targetPosition: attrs.current_position 
+                                };
                                 syncDataList.push({ type: 'position', value: attrs.current_position });
                             }
                         }
-                        // 窗帘动作
+                        
+                        // 窗帘动作 - open/closed 状态变化
                         if (newState.state !== oldState?.state) {
                             if (newState.state === 'open') {
+                                node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
                                 syncDataList.push({ type: 'curtain_action', value: 'open' });
                             } else if (newState.state === 'closed') {
+                                node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
                                 syncDataList.push({ type: 'curtain_action', value: 'close' });
                             }
                         }
@@ -419,7 +671,11 @@ module.exports = function(RED) {
                         // 开关状态
                         if (!oldState || newState.state !== oldState.state) {
                             const isOn = newState.state !== 'off' && newState.state !== 'unavailable';
-                            syncDataList.push({ type: 'switch', value: isOn });
+                            // 仅当状态从off变on，或on变off时才同步开关
+                            if ((oldState && oldState.state === 'off' && newState.state !== 'off') || 
+                                (oldState && oldState.state !== 'off' && newState.state === 'off')) {
+                                syncDataList.push({ type: 'switch', value: isOn });
+                            }
                         }
                         // 目标温度
                         if (attrs.temperature !== undefined) {
@@ -428,9 +684,10 @@ module.exports = function(RED) {
                             }
                         }
                         // HVAC模式
-                        if (attrs.hvac_mode !== undefined || newState.state !== oldState?.state) {
+                        // 过滤掉off模式的变化，因为off已经由开关状态处理
+                        if (newState.state !== 'off' && (attrs.hvac_mode !== undefined || newState.state !== oldState?.state)) {
                             const hvacMode = attrs.hvac_mode || newState.state;
-                            if (!oldState || (oldAttrs.hvac_mode || oldState.state) !== hvacMode) {
+                            if (hvacMode !== 'off' && (!oldState || (oldAttrs.hvac_mode || oldState.state) !== hvacMode)) {
                                 const meshMode = HA_TO_AC_MODE[hvacMode];
                                 if (meshMode !== undefined) {
                                     syncDataList.push({ type: 'hvac_mode', value: meshMode });
@@ -471,7 +728,9 @@ module.exports = function(RED) {
                 
                 // 队列同步命令
                 syncDataList.forEach(syncData => {
-                    if (node.shouldPreventSync('ha-to-symi', loopKey)) {
+                    // 窗帘使用专门的运动状态跟踪，不使用常规防死循环
+                    const isCover = domain === 'cover';
+                    if (!isCover && node.shouldPreventSync('ha-to-symi', loopKey)) {
                         node.debug(`[HA->Symi] 跳过(防死循环): ${loopKey} ${syncData.type}`);
                         return;
                     }
@@ -480,7 +739,8 @@ module.exports = function(RED) {
                         direction: 'ha-to-symi',
                         mapping: mapping,
                         syncData: syncData,
-                        key: loopKey
+                        key: loopKey,
+                        skipLoopCheck: isCover  // 窗帘跳过常规防死循环检查
                     });
                 });
             });
@@ -585,8 +845,9 @@ module.exports = function(RED) {
                             service = 'set_fan_mode';
                             serviceData.fan_mode = syncData.value;
                         } else if (domain === 'fan') {
+                            // 区分新风和普通风扇
+                            // 如果是新风且HA实体是fan
                             service = 'set_percentage';
-                            // 风速档位转百分比
                             const percentMap = { high: 100, medium: 66, low: 33, auto: 50 };
                             serviceData.percentage = percentMap[syncData.value] || 50;
                         }
@@ -608,7 +869,8 @@ module.exports = function(RED) {
                 
                 node.log(`[Symi->HA] ${mapping.symiName || mapping.symiMac} -> ${mapping.haEntityId}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
-                // 输出到debug
+                // 仅输出到debug，不再重复send
+                /*
                 node.send({
                     topic: 'ha-sync/symi-to-ha',
                     payload: {
@@ -621,6 +883,7 @@ module.exports = function(RED) {
                         timestamp: Date.now()
                     }
                 });
+                */
                 
             } catch (err) {
                 node.error(`[Symi->HA] 调用失败: ${err.message}`);
@@ -642,6 +905,16 @@ module.exports = function(RED) {
             const channels = device.channels;
             const targetChannel = mapping.symiKey;
             
+            // 检查是否是三合一设备（symiKey为字符串类型）
+            const isThreeInOne = typeof targetChannel === 'string' && 
+                ['aircon', 'fresh_air', 'floor_heating'].includes(targetChannel);
+            
+            if (isThreeInOne) {
+                // 三合一设备使用专门的控制函数
+                await node.syncThreeInOne(cmd, device, networkAddr);
+                return;
+            }
+            
             try {
                 let attrType, param;
                 
@@ -692,23 +965,77 @@ module.exports = function(RED) {
                 
                 node.log(`[HA->Symi] ${mapping.haEntityId} -> ${device.name || mapping.symiMac}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
-                // 输出到debug
-                node.send({
-                    topic: 'ha-sync/ha-to-symi',
-                    payload: {
-                        direction: 'HA→Symi',
-                        haEntityId: mapping.haEntityId,
-                        symiMac: mapping.symiMac,
-                        symiKey: mapping.symiKey,
-                        syncType: syncData.type,
-                        value: syncData.value,
-                        attrType: attrType,
-                        timestamp: Date.now()
+            } catch (err) {
+                node.error(`[HA->Symi] 控制失败: ${err.message}`);
+            }
+        };
+
+        // ========== 执行 三合一控制 ==========
+        node.syncThreeInOne = async function(cmd, device, networkAddr) {
+            const { mapping, syncData } = cmd;
+            const subType = mapping.symiKey;
+            
+            try {
+                let attrType, param;
+                
+                if (subType === 'aircon') {
+                    // 空调控制
+                    switch (syncData.type) {
+                        case 'switch':
+                            attrType = ATTR_SWITCH;
+                            param = [syncData.value ? 0x02 : 0x01];
+                            break;
+                        case 'temperature':
+                            attrType = ATTR_TARGET_TEMP;
+                            param = [syncData.value];
+                            break;
+                        case 'hvac_mode':
+                            attrType = ATTR_CLIMATE_MODE;
+                            // HA mode -> Mesh mode
+                            const haToMeshMode = { cool: 1, heat: 2, fan_only: 3, dry: 4, off: 0 };
+                            param = [haToMeshMode[syncData.value] || 1];
+                            break;
+                        case 'fan_mode':
+                            attrType = ATTR_FAN_MODE;
+                            // HA fan -> Mesh fan
+                            const haToMeshFan = { high: 1, medium: 2, low: 3, auto: 4 };
+                            param = [haToMeshFan[syncData.value] || 4];
+                            break;
                     }
-                });
+                } else if (subType === 'fresh_air') {
+                    // 新风控制
+                    switch (syncData.type) {
+                        case 'switch':
+                            attrType = ATTR_FRESH_AIR_SWITCH;
+                            param = [syncData.value ? 0x02 : 0x01];
+                            break;
+                        case 'fan_mode':
+                            attrType = ATTR_FRESH_AIR_SPEED;
+                            const haToMeshFan = { high: 1, medium: 2, low: 3, auto: 4 };
+                            param = [haToMeshFan[syncData.value] || 4];
+                            break;
+                    }
+                } else if (subType === 'floor_heating') {
+                    // 地暖控制
+                    switch (syncData.type) {
+                        case 'switch':
+                            attrType = ATTR_FLOOR_HEATING_SWITCH;
+                            param = [syncData.value ? 0x02 : 0x01];
+                            break;
+                        case 'temperature':
+                            attrType = ATTR_FLOOR_HEATING_TEMP;
+                            param = [syncData.value];
+                            break;
+                    }
+                }
+                
+                if (attrType && param) {
+                    await gateway.sendControl(networkAddr, attrType, param);
+                    node.log(`[HA->Symi] ${mapping.haEntityId} -> ${mapping.symiName}(${subType}): ${syncData.type}=${JSON.stringify(syncData.value)}`);
+                }
                 
             } catch (err) {
-                node.error(`[HA->Symi] 控制失败: ${err.message}`);
+                node.error(`[HA->Symi] 三合一控制失败: ${err.message}`);
             }
         };
 
@@ -722,6 +1049,8 @@ module.exports = function(RED) {
                 clearTimeout(node.pendingDebounce[key]);
             }
             node.pendingDebounce = {};
+            node.coverMoving = {};       // 清理窗帘运动状态
+            node.brightnessMoving = {};  // 清理调光运动状态
             
             if (gateway) {
                 gateway.removeListener('device-state-changed', node.handleSymiStateChange);
@@ -739,7 +1068,7 @@ module.exports = function(RED) {
     // ========== HTTP API ==========
     
     // 加载Symi设备
-    RED.httpAdmin.get('/symi-ha-sync/symi-devices/:id', function(req, res) {
+    RED.httpAdmin.get('/symi-ha-sync/symi-devices/:id', RED.auth.needsPermission('symi-ha-sync.read'), function(req, res) {
         const mqttNode = RED.nodes.getNode(req.params.id);
         if (!mqttNode || !mqttNode.gateway) {
             return res.json([]);

package/nodes/symi-mqtt-sync.js

@@ -293,33 +293,86 @@ module.exports = function(RED) {
 
             let property = '', value = null;
             try {
-                if (fn === 1) {
-                    property = 'switch'; value = fv === 1;
-                    node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
-                } else if (fn === 2) {
-                    property = typeInfo.meshType === 'light' ? 'brightness' : 
-                               typeInfo.meshType === 'cover' ? 'position' : 'temperature';
-                    value = fv;
-                    node._gateway.deviceManager.controlDevice(meshMac, meshChannel, property, fv);
-                } else if (fn === 3) {
-                    if (typeInfo.meshType === 'climate') {
+                // 窗帘设备特殊处理 (typeId=14)
+                if (deviceType === 14) {
+                    if (fn === 1) {
+                        // fn=1: 窗帘动作控制 (fv: 0=关闭, 1=打开, 2=停止)
+                        if (fv === 1) {
+                            property = 'curtainAction'; value = 'open';
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'curtainAction', 'open');
+                        } else if (fv === 0) {
+                            property = 'curtainAction'; value = 'close';
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'curtainAction', 'close');
+                        } else if (fv === 2) {
+                            property = 'curtainAction'; value = 'stop';
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'curtainAction', 'stop');
+                        }
+                    } else if (fn === 2) {
+                        // fn=2: 窗帘位置 (fv: 0-100%)
+                        property = 'position'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'position', fv);
+                    }
+                }
+                // 灯具设备 (typeId=8)
+                else if (deviceType === 8) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 2) {
+                        property = 'brightness'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'brightness', fv);
+                    }
+                }
+                // 空调设备 (typeId=12)
+                else if (deviceType === 12) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 2) {
+                        property = 'temperature'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'temperature', fv);
+                    } else if (fn === 3) {
                         const mode = AC_MODE_MAP[fv];
                         if (mode) {
                             property = 'mode'; value = mode;
                             node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'mode', mode);
                         }
-                    } else if (typeInfo.meshType === 'fan') {
+                    } else if (fn === 4) {
+                        const speed = FAN_SPEED_MAP[fv];
+                        if (speed) {
+                            property = 'fanSpeed'; value = speed;
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
+                        }
+                    }
+                }
+                // 地暖设备 (typeId=16)
+                else if (deviceType === 16) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 2) {
+                        property = 'temperature'; value = fv;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'temperature', fv);
+                    }
+                }
+                // 新风设备 (typeId=36)
+                else if (deviceType === 36) {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                    } else if (fn === 3) {
                         const speed = FAN_SPEED_MAP[fv];
                         if (speed) {
                             property = 'fanSpeed'; value = speed;
                             node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
                         }
                     }
-                } else if (fn === 4 && typeInfo.meshType === 'climate') {
-                    const speed = FAN_SPEED_MAP[fv];
-                    if (speed) {
-                        property = 'fanSpeed'; value = speed;
-                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
+                }
+                // 其他设备类型的通用处理
+                else {
+                    if (fn === 1) {
+                        property = 'switch'; value = fv === 1;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
                     }
                 }
                 
@@ -335,7 +388,9 @@ module.exports = function(RED) {
                         }
                     });
                 }
-            } catch (e) {}
+            } catch (e) {
+                node.warn(`[Brand→Mesh] 同步失败: ${e.message}`);
+            }
         }
 
         // ===== 同步到MQTT =====
@@ -353,18 +408,86 @@ module.exports = function(RED) {
             const typeInfo = node._brandProtocol.deviceTypes[deviceType];
             if (!typeInfo) return;
 
-            // 根据属性确定功能码
-            let fn;
-            if (property === 'switch' || property === 'on' || property === 'isOn') {
-                fn = 1;
-            } else if (property === 'brightness' || property === 'temperature' || property === 'position') {
-                fn = 2;
-            } else if (property === 'mode' || property === 'hvacMode') {
-                fn = 3;
-            } else if (property === 'fanSpeed' || property === 'fanMode') {
-                fn = typeInfo.meshType === 'climate' ? 4 : 3;
-            } else {
-                return;
+            // 根据设备类型和属性确定功能码
+            let fn, fv;
+            
+            // 窗帘设备特殊处理 (typeId=14)
+            if (deviceType === 14) {
+                if (property === 'curtainAction' || property === 'action') {
+                    fn = 1;
+                    if (value === 'open' || value === 1) fv = 1;
+                    else if (value === 'close' || value === 0) fv = 0;
+                    else if (value === 'stop' || value === 2) fv = 2;
+                    else return;
+                } else if (property === 'position' || property === 'curtainPosition') {
+                    fn = 2;
+                    fv = parseInt(value) || 0;
+                } else {
+                    return;
+                }
+            }
+            // 灯具设备 (typeId=8)
+            else if (deviceType === 8) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'brightness') {
+                    fn = 2;
+                    fv = parseInt(value) || 0;
+                } else {
+                    return;
+                }
+            }
+            // 空调设备 (typeId=12)
+            else if (deviceType === 12) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'temperature' || property === 'targetTemp') {
+                    fn = 2;
+                    fv = parseInt(value) || 24;
+                } else if (property === 'mode' || property === 'hvacMode' || property === 'climateMode') {
+                    fn = 3;
+                    fv = AC_MODE_REVERSE[value] ?? 0;
+                } else if (property === 'fanSpeed' || property === 'fanMode') {
+                    fn = 4;
+                    fv = FAN_SPEED_REVERSE[value] ?? 0;
+                } else {
+                    return;
+                }
+            }
+            // 地暖设备 (typeId=16)
+            else if (deviceType === 16) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'temperature' || property === 'targetTemp') {
+                    fn = 2;
+                    fv = parseInt(value) || 20;
+                } else {
+                    return;
+                }
+            }
+            // 新风设备 (typeId=36)
+            else if (deviceType === 36) {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else if (property === 'fanSpeed' || property === 'fanMode') {
+                    fn = 3;
+                    fv = FAN_SPEED_REVERSE[value] ?? 0;
+                } else {
+                    return;
+                }
+            }
+            // 其他设备类型的通用处理
+            else {
+                if (property === 'switch' || property === 'on' || property === 'isOn') {
+                    fn = 1;
+                    fv = value ? 1 : 0;
+                } else {
+                    return;
+                }
             }
 
             // 防死循环 - 检查两个方向的时间戳
@@ -381,19 +504,6 @@ module.exports = function(RED) {
             node._syncTimestamps.set(meshSyncKey, now);
             node._syncTimestamps.set(mqttSyncKey, now);
 
-            let fv;
-            if (property === 'switch' || property === 'on' || property === 'isOn') {
-                fv = value ? 1 : 0;
-            } else if (property === 'brightness' || property === 'temperature' || property === 'position') {
-                fv = parseInt(value) || 0;
-            } else if (property === 'mode' || property === 'hvacMode') {
-                fv = AC_MODE_REVERSE[value] ?? 0;
-            } else if (property === 'fanSpeed' || property === 'fanMode') {
-                fv = FAN_SPEED_REVERSE[value] ?? 0;
-            } else {
-                return;
-            }
-
             const topic = node._brandProtocol.getDownTopic(node);
             const payload = node._brandProtocol.buildMessage(deviceType, deviceId, fn, fv);
 
@@ -410,7 +520,9 @@ module.exports = function(RED) {
                         timestamp: Date.now()
                     }
                 });
-            } catch (e) {}
+            } catch (e) {
+                node.warn(`[Mesh→Brand] 同步失败: ${e.message}`);
+            }
         }
 
         // ===== 网关事件监听 =====

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {