node-red-contrib-symi-mesh 1.8.1 → 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,18 @@ 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同步节点新增三合一子设备选择功能，可分别选择“空调”、“新风”、“地暖”进行独立映射。
@@ -1600,7 +1693,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.8.1
+**版本**: 1.8.2
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2026-01-05
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

package/nodes/symi-ha-sync.js

@@ -1,6 +1,6 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.1
+ * 版本: 1.8.2
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -15,7 +15,7 @@ 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;
@@ -23,6 +23,9 @@ module.exports = function(RED) {
     // 窗帘专用常量
     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;
@@ -92,6 +95,7 @@ module.exports = function(RED) {
         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: '初始化中' });
 
@@ -130,10 +134,17 @@ module.exports = function(RED) {
             
             // 清理过期的窗帘运动状态
             for (const key in node.coverMoving) {
-                if (now - node.coverMoving[key].timestamp > COVER_LOOP_PREVENTION_MS) {
+                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);
 
         // 防死循环检查 - 双向时间戳检查
@@ -367,14 +378,47 @@ 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;  // 不立即同步，由定时器处理
         };
 
         // 处理窗帘变化（带防抖，避免步进反馈干扰）
@@ -487,19 +531,47 @@ module.exports = function(RED) {
             }
         });
         
-        // 方式B: 尝试订阅HA Server事件总线
-        if (node.haServer && node.haServer.eventBus) {
-            node.haEventHandler = (evt) => {
-                // node.debug(`[HA事件] type=${evt.event_type}, data=${JSON.stringify(evt.data)}`);
-                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事件总线');
-        } else {
-            node.warn('[HA同步] 未能订阅HA事件总线，请确保HA节点配置正确且已连接');
-        }
+                
+                setTimeout(subscribeToHaEvents, 5000);
+            }
+        };
+        
+        // 启动后立即开始静默尝试
+        subscribeToHaEvents();
 
         node.handleHaStateChange = function(entityId, newState, oldState) {
             if (!newState) return;
@@ -545,6 +617,8 @@ 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 });
                             }
                         }
@@ -831,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;
                 
@@ -881,23 +965,6 @@ module.exports = function(RED) {
                 
                 node.log(`[HA->Symi] ${mapping.haEntityId} -> ${device.name || mapping.symiMac}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
-                // 仅输出到debug，不再重复send
-                /*
-                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}`);
             }
@@ -982,7 +1049,8 @@ module.exports = function(RED) {
                 clearTimeout(node.pendingDebounce[key]);
             }
             node.pendingDebounce = {};
-            node.coverMoving = {};  // 清理窗帘运动状态
+            node.coverMoving = {};       // 清理窗帘运动状态
+            node.brightnessMoving = {};  // 清理调光运动状态
             
             if (gateway) {
                 gateway.removeListener('device-state-changed', node.handleSymiStateChange);

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.1",
+  "version": "1.8.2",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {