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

package/README.md

@@ -393,8 +393,8 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
    - 复用`symi-mqtt`配置节点获取Symi设备信息
    - 复用`server`配置节点连接Home Assistant
 2. **双向同步**：
-   - **Symi -> HA**：Mesh设备状态变化 -> 更新HA实体状态
-   - **HA -> Symi**：HA实体状态变化 -> 控制Mesh设备
+   - **Symi -> HA**：Mesh设备状态变化 -> 更新HA实体状态（自动工作）
+   - **HA -> Symi**：HA实体状态变化 -> 控制Mesh设备（需连接HA事件节点）
 3. **防死循环**：
    - 内置2秒冷却机制（窗帘30秒）
    - 区分Symi触发和HA触发，避免信号震荡
@@ -403,6 +403,37 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
    - 支持按键通道选择（1-4键）
    - 支持实体ID搜索和下拉选择
 
+#### ⚠️ 双向同步连接方式（重要）
+
+要实现完整的双向同步，必须连接HA事件节点到`symi-ha-sync`节点的输入端：
+
+**方式1：使用 server-events 节点（推荐）**
+```
+[events: all] → [symi-ha-sync]
+  (事件类型: state_changed)
+```
+
+配置步骤：
+1. 添加 `events: all` 节点（Home Assistant 分类下）
+2. 事件类型(Event Type)填写: `state_changed`
+3. 将输出连接到 symi-ha-sync 节点的输入端
+
+**方式2：使用 server-state-changed 节点**
+```
+[events: state] → [symi-ha-sync]
+```
+
+配置步骤：
+1. 添加 `events: state` 节点
+2. 实体ID可留空（监听所有实体）或指定特定实体
+3. 将输出连接到 symi-ha-sync 节点的输入端
+
+#### 状态指示
+
+- **蓝色 "Mesh→HA (N组)"**：仅 Mesh 到 HA 方向工作（未连接 HA 事件节点）
+- **绿色 "双向同步 (N组)"**：双向同步正常工作
+- **红色**：配置错误
+
 #### 配置步骤
 
 1. **添加节点**：从左侧拖入`Symi HA Sync`节点
@@ -413,14 +444,17 @@ Symi HA同步节点 (`symi-ha-sync`) 用于实现Symi蓝牙Mesh设备与Home Ass
    - **Symi设备**：下拉选择Mesh设备（显示名称和MAC）
    - **按键**：选择控制通道（按键1-4）
    - **HA实体**：输入或选择要同步的HA实体ID（如`switch.living_room_light`）
-5. **部署**：点击部署，立即生效
+5. **连接HA事件节点**：添加`events: all`或`events: state`节点，连接到输入端
+6. **部署**：点击部署，立即生效
 
 #### 注意事项
 
 - **MQTT配置**：必须选择`symi-mqtt`配置节点，用于获取设备列表和接收Mesh事件
 - **HA连接**：必须确保HA服务器节点连接正常
+- **HA事件节点**：必须连接HA事件节点才能实现HA→Symi方向同步
 - **实体类型**：建议同步相同类型的实体（如开关对开关，调光灯对灯光）
 - **多通道设备**：对于多键开关，请分别为每个按键添加一条映射
+- **event实体过滤**：系统自动过滤`event.`开头的实体（如按键点击事件），不会同步
 
 #### 三合一面板配置
 
@@ -1501,6 +1535,28 @@ node-red-contrib-symi-mesh/
 - 无TODO/FIXME/HACK标记
 - 代码无重复，模块化设计
 
+## 更新日志
+
+### v1.8.3 (2026-01-05)
+
+**HA同步节点重大修复**：
+- 修复HA→Symi方向不工作的问题（input监听器未正确注册）
+- 支持多种HA节点消息格式（server-events、server-state-changed、trigger:state等）
+- 自动过滤event类型实体（如按键点击事件），避免无效同步
+- 优化状态显示：蓝色"Mesh→HA"表示单向，绿色"双向同步"表示双向正常
+- 精简日志输出，只记录映射中的实体状态变化
+- 更新HTML帮助文档，详细说明双向同步连接方式
+- 更新README文档，添加完整的HA同步配置指南
+
+**连接方式说明**：
+- Symi→HA：自动工作，无需额外配置
+- HA→Symi：需连接`events: all`或`events: state`节点到symi-ha-sync输入端
+
+### v1.8.2 (2025-12-xx)
+
+- 窗帘和调光灯智能防抖，只同步最终状态
+- 三合一面板完整双向同步支持
+
 ## 技术支持
 
 如遇问题，请提供以下信息：
@@ -1584,6 +1640,21 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.3 (2026-01-05)
+
+**HA同步节点重大修复**：
+- 修复HA→Symi方向不工作的问题（input监听器未正确注册）
+- 支持多种HA节点消息格式（server-events、server-state-changed、trigger:state等）
+- 自动过滤event类型实体（如按键点击事件），避免无效同步
+- 优化状态显示：蓝色"Mesh→HA"表示单向，绿色"双向同步"表示双向正常
+- 精简日志输出，只记录映射中的实体状态变化
+- 更新HTML帮助文档，详细说明双向同步连接方式
+- 更新README文档，添加完整的HA同步配置指南
+
+**连接方式说明**：
+- Symi→HA：自动工作，无需额外配置
+- HA→Symi：需连接`events: all`或`events: state`节点到symi-ha-sync输入端
+
 ### v1.8.2 (2026-01-05)
 - **MQTT品牌同步协议修复**：
   - **窗帘设备协议修复**：修复窗帘fn=1功能码的正确解析（0=关闭, 1=打开, 2=停止），之前错误地当作开关处理
@@ -1626,62 +1697,6 @@ node-red-contrib-symi-mesh/
   - 优化了双向同步的防死循环逻辑，减少了在高频触发场景下的 CPU 占用。
   - 修复了 MQTT 配置下拉框在节点编辑面板打开时偶尔出现的加载卡顿问题。
 
-### v1.7.9 (2026-01-05)
-- **HA同步节点UI修复**：修复添加映射按钮不显示选择界面的问题
-  - 修复`renderMappings()`函数中的数组检查逻辑
-  - 修复`mergeDevices()`函数中的空值检查
-  - 使用`entityType`字段判断设备类型（climate/cover/light不显示按键选择）
-  - 添加设备类型标签显示：[温控器]、[窗帘]、[灯具]、[N路开关]、[单路开关]
-  - 添加错误捕获和日志输出，便于调试
-
-### v1.7.8 (2026-01-05)
-- **配置持久化增强**：所有同步节点的设备列表和映射配置持久保存
-  - **MQTT同步节点**：Mesh设备和品牌设备列表持久化，断线后仍可显示已配置的映射
-  - **HA同步节点**：Symi设备和HA实体列表持久化，断线后仍可显示已配置的映射
-  - **RS485桥接节点**：Mesh设备列表持久化，断线后仍可显示已配置的映射
-  - **离线设备显示**：[离线]标记缓存中但当前不在线的设备，[未找到]标记不在缓存中的设备
-  - **刷新按钮**：各节点添加独立刷新按钮，可手动刷新设备列表
-- **MQTT品牌同步增强**：完整对接HYQW（花语前湾）MQTT协议
-  - **完整设备类型支持**：灯具(8)、空调(12)、窗帘(14)、地暖(16)、新风(36)
-  - **功能码映射**：完整的fn/fv到Mesh属性双向转换
-    - 灯具：开关(fn=1)、亮度(fn=2, 0-100)
-    - 空调：开关(fn=1)、温度(fn=2, 18-29°C)、模式(fn=3)、风速(fn=4)
-    - 窗帘：动作(fn=1, 开/关/停)、位置(fn=2, 0-100%)
-    - 地暖：开关(fn=1)、温度(fn=2, 5-35°C)
-    - 新风：开关(fn=1)、风速(fn=3)
-  - **可扩展架构**：BRAND_PROTOCOLS对象支持添加新品牌协议
-  - **双向状态同步**：HYQW↔Mesh实时同步，2秒防抖防死循环
-  - **自动设备发现**：自动发现品牌MQTT设备，限制200个
-  - **错误日志限流**：每60秒最多记录一次错误，避免日志爆炸
-  - **自动重连**：5秒重连间隔，断线自动恢复
-  - **资源清理**：完善的定时器和事件监听器清理机制
-- **HA同步节点完整重构**：实现所有实体类型的完美双向同步
-  - **完整实体类型支持**：
-    - switch/input_boolean：开关状态 (on/off)
-    - light：开关 + 亮度 (0-255 ↔ 0-100)
-    - cover：开/关/停 + 位置 (0-100%)
-    - climate：开关 + 温度 + 模式(cool/heat/fan_only/dry) + 风速(high/medium/low/auto)
-    - fan：开关 + 风速
-  - **Mesh属性完整映射**：
-    - 0x02 开关状态（单路/多路）
-    - 0x03 亮度 (0-100)
-    - 0x05 窗帘运行状态
-    - 0x06 窗帘位置 (0-100)
-    - 0x1B 目标温度 (16-30°C)
-    - 0x1C 风速 (1=高/2=中/3=低/4=自动)
-    - 0x1D 空调模式 (1=制冷/2=制热/3=送风/4=除湿)
-  - **智能按键选择**：只有多路开关才显示按键选择，温控器/窗帘/调光灯显示"-"
-  - **设备类型标签**：自动识别并显示设备类型（[温控器]、[窗帘]、[调光灯]、[N路开关]）
-  - **智能防抖机制**：窗帘和调光灯使用500ms防抖，只同步最终位置/亮度
-  - **防死循环增强**：2秒冷却时间 + 双向时间戳检查
-  - **配置持久化**：设备列表和映射配置持久保存
-  - **内存泄漏防护**：定时清理过期时间戳和防抖定时器
-- **代码质量优化**：
-  - 同步时间戳Map自动清理60秒以上的条目
-  - 设备发现数量限制，防止内存溢出
-  - 完善的节点关闭清理逻辑
-  - 防死循环机制增强：双向时间戳检查
-
 ## 许可证
 
 MIT License
@@ -1693,7 +1708,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.8.2
+**版本**: 1.8.3
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2026-01-05
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

package/nodes/symi-ha-sync.html

@@ -477,11 +477,44 @@
     <h3>功能特性</h3>
     <ul>
         <li><strong>完美双向同步</strong>：Symi↔HA实时状态同步</li>
-        <li><strong>多设备类型支持</strong>：开关、调光灯、窗帘、温控器/空调</li>
+        <li><strong>多设备类型支持</strong>：开关、调光灯、窗帘、温控器/空调、新风、地暖</li>
         <li><strong>智能按键选择</strong>：只有多路开关才显示按键选择</li>
         <li><strong>配置持久化</strong>：设备列表和映射配置持久保存</li>
         <li><strong>防死循环</strong>：内置2秒防抖机制</li>
-        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置</li>
+        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置，过程状态不同步</li>
+    </ul>
+
+    <h3>⚠️ 双向同步连接方式（重要）</h3>
+    <p>要实现 HA→Symi 方向同步，必须连接 HA 事件节点到本节点输入端：</p>
+    
+    <h4>方式1：使用 server-events 节点（推荐）</h4>
+    <pre>
+[server-events] → [symi-ha-sync]
+    (事件类型: state_changed)
+    </pre>
+    <p><strong>配置步骤：</strong></p>
+    <ol>
+        <li>添加 <code>events: all</code> 节点（Home Assistant 分类下）</li>
+        <li>事件类型(Event Type)填写: <code>state_changed</code></li>
+        <li>将输出连接到 symi-ha-sync 节点的输入端</li>
+    </ol>
+    
+    <h4>方式2：使用 server-state-changed 节点</h4>
+    <pre>
+[server-state-changed] → [symi-ha-sync]
+    </pre>
+    <p><strong>配置步骤：</strong></p>
+    <ol>
+        <li>添加 <code>events: state</code> 节点</li>
+        <li>实体ID可留空（监听所有实体）或指定特定实体</li>
+        <li>将输出连接到 symi-ha-sync 节点的输入端</li>
+    </ol>
+
+    <h3>状态指示</h3>
+    <ul>
+        <li><strong>蓝色 "Mesh→HA"</strong>：仅 Mesh 到 HA 方向工作（未连接 HA 事件节点）</li>
+        <li><strong>绿色 "双向同步"</strong>：双向同步正常工作</li>
+        <li><strong>红色</strong>：配置错误</li>
     </ul>
 
     <h3>支持的设备类型</h3>
@@ -490,6 +523,15 @@
         <li><strong>调光灯</strong>：开关 + 亮度 (0-100)</li>
         <li><strong>窗帘</strong>：开/关/停 + 位置 (0-100%)</li>
         <li><strong>温控器/空调</strong>：开关 + 温度 + 模式 + 风速</li>
+        <li><strong>三合一面板</strong>：空调 + 新风 + 地暖，分别配置</li>
+    </ul>
+
+    <h3>三合一面板配置</h3>
+    <p>三合一面板需要分别为每个子设备创建映射：</p>
+    <ul>
+        <li><strong>空调</strong>：选择子设备"空调"，映射到 climate 实体</li>
+        <li><strong>新风</strong>：选择子设备"新风"，映射到 fan 实体</li>
+        <li><strong>地暖</strong>：选择子设备"地暖"，映射到 climate 实体</li>
     </ul>
 
     <h3>离线设备显示</h3>

package/nodes/symi-ha-sync.js

@@ -1,6 +1,6 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.2
+ * 版本: 1.8.3
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -96,28 +96,48 @@ module.exports = function(RED) {
         node.pendingDebounce = {};  // 防抖定时器
         node.coverMoving = {};      // 窗帘运动状态跟踪 { loopKey: { direction: 'symi'|'ha', startTime, targetPosition } }
         node.brightnessMoving = {}; // 调光运动状态跟踪 { loopKey: { direction: 'ha', startTime } }
+        node.haInputReceived = false;  // 是否收到过HA输入
         
         node.status({ fill: 'yellow', shape: 'ring', text: '初始化中' });
+        
+        // 更新状态显示的辅助函数
+        node.updateStatus = function() {
+            if (configError) {
+                node.status({ fill: 'red', shape: 'ring', text: configError });
+            } else if (node.haInputReceived) {
+                node.status({ fill: 'green', shape: 'dot', text: `双向同步 (${node.mappings.length}组)` });
+            } else if (gateway) {
+                node.status({ fill: 'blue', shape: 'dot', text: `Mesh→HA (${node.mappings.length}组)` });
+            } else {
+                node.status({ fill: 'yellow', shape: 'ring', text: '等待连接' });
+            }
+        };
 
-        // 检查配置
+        // 检查配置 - 但不要直接return，允许input监听器注册
+        let gateway = null;
+        let configError = null;
+        
         if (!node.mqttNode) {
-            node.status({ fill: 'red', shape: 'ring', text: '未配置MQTT节点' });
-            return;
-        }
-        if (!node.haServer) {
-            node.status({ fill: 'red', shape: 'ring', text: '未配置HA服务器' });
-            return;
+            configError = '未配置MQTT节点';
+        } else if (!node.haServer) {
+            configError = '未配置HA服务器';
+        } else {
+            // 获取Gateway引用
+            gateway = node.mqttNode.gateway;
+            if (!gateway) {
+                configError = 'MQTT节点未关联网关';
+            }
         }
-
-        // 获取Gateway引用
-        const gateway = node.mqttNode.gateway;
-        if (!gateway) {
-            node.status({ fill: 'red', shape: 'ring', text: 'MQTT节点未关联网关' });
-            return;
+        
+        if (configError) {
+            node.status({ fill: 'red', shape: 'ring', text: configError });
+            node.warn(`[HA同步] ${configError}`);
+            // 不要return，继续注册input监听器
+        } else {
+            // 初始状态：只有Mesh→HA方向，等待HA输入连接
+            node.updateStatus();
         }
 
-        node.status({ fill: 'green', shape: 'dot', text: `运行中 (${node.mappings.length}组)` });
-
         // 定期清理过期的防抖时间戳
         node.cleanupInterval = setInterval(function() {
             const now = Date.now();
@@ -145,6 +165,16 @@ module.exports = function(RED) {
                     delete node.brightnessMoving[key];
                 }
             }
+            
+            // 尝试重新获取gateway（如果之前没有）
+            if (!gateway && node.mqttNode && node.mqttNode.gateway) {
+                gateway = node.mqttNode.gateway;
+                if (gateway) {
+                    node.log('[HA同步] 网关已就绪，注册设备状态监听');
+                    gateway.on('device-state-changed', node.handleSymiStateChange);
+                    node.status({ fill: 'green', shape: 'dot', text: `运行中 (${node.mappings.length}组)` });
+                }
+            }
         }, CLEANUP_INTERVAL_MS);
 
         // 防死循环检查 - 双向时间戳检查
@@ -510,74 +540,157 @@ module.exports = function(RED) {
             return { type: 'hvac_mode', value: haMode, meshValue: mode };
         };
 
-        // 监听网关事件
-        gateway.on('device-state-changed', node.handleSymiStateChange);
+        // 监听网关事件（如果gateway可用）
+        if (gateway) {
+            gateway.on('device-state-changed', node.handleSymiStateChange);
+        }
 
         // ========== 2. 监听HA状态变化 (HA -> Symi) ==========
         
-        // 方式A: 通过Input输入 (server-state-changed节点)
+        // 方式A: 通过Input输入 (支持多种HA节点格式)
         node.on('input', function(msg) {
-            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);
+            // 首次收到HA输入时更新状态
+            if (!node.haInputReceived) {
+                node.haInputReceived = true;
+                node.updateStatus();
+                node.log('[HA同步] 已收到HA输入，双向同步已启用');
+            }
+            
+            // 支持多种消息格式
+            let entityId, newState, oldState;
+            
+            // 格式1: server-events 节点格式 (msg.payload.event_type + msg.payload.event)
+            // 实际格式: { event_type: "state_changed", entity_id: "...", event: { entity_id, new_state, old_state } }
+            if (msg.payload && msg.payload.event_type === 'state_changed') {
+                entityId = msg.payload.entity_id;
+                // event 直接包含 new_state 和 old_state（不是 event.data）
+                if (msg.payload.event) {
+                    newState = msg.payload.event.new_state;
+                    oldState = msg.payload.event.old_state;
                 }
-            } 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);
             }
+            // 格式2: server-state-changed 节点的标准格式 (msg.data)
+            else if (msg.data && msg.data.entity_id) {
+                entityId = msg.data.entity_id;
+                newState = msg.data.new_state;
+                oldState = msg.data.old_state;
+            }
+            // 格式3: payload 中直接包含 entity_id 和 new_state
+            else if (msg.payload && msg.payload.entity_id && msg.payload.new_state) {
+                entityId = msg.payload.entity_id;
+                newState = msg.payload.new_state;
+                oldState = msg.payload.old_state;
+            }
+            // 格式4: 直接的 event 数据 (msg.event)
+            else if (msg.event && msg.event.new_state) {
+                entityId = msg.event.entity_id;
+                newState = msg.event.new_state;
+                oldState = msg.event.old_state;
+            }
+            // 格式5: trigger: state 节点格式 (msg.payload 是状态对象)
+            else if (msg.payload && typeof msg.payload === 'object' && 
+                     msg.payload.state !== undefined && msg.payload.attributes !== undefined) {
+                entityId = msg.topic || msg.payload.entity_id;
+                newState = msg.payload;
+                oldState = null;
+            }
+            
+            // 过滤非 state_changed 事件和无效数据
+            if (!entityId || !newState) {
+                return;  // 静默忽略无法解析的消息
+            }
+            
+            // 过滤 event 类型的实体（如 event.xxx_click_e_xxx），这些不需要同步
+            if (entityId.startsWith('event.')) {
+                return;
+            }
+            
+            // 检查是否在映射列表中
+            const mappings = node.findMappingsByHa(entityId);
+            if (mappings.length === 0) {
+                return;  // 不在映射中的实体静默忽略
+            }
+            
+            // 只记录映射中的实体状态变化
+            node.log(`[HA->Symi] ${entityId}: ${oldState?.state || 'null'} -> ${newState.state}`);
+            node.handleHaStateChange(entityId, newState, oldState);
         });
         
-        // 方式B: 尝试订阅HA Server事件总线 (静默订阅机制)
+        // 方式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) {
+            // 尝试多种方式获取事件总线
+            let eventBus = null;
+            
+            // 方式1: 直接访问 eventBus
+            if (node.haServer.eventBus) {
+                eventBus = node.haServer.eventBus;
+            }
+            // 方式2: 通过 controller
+            else if (node.haServer.controller && node.haServer.controller.events) {
                 eventBus = node.haServer.controller.events;
             }
+            // 方式3: 通过 websocket
+            else if (node.haServer.websocket && node.haServer.websocket.eventBus) {
+                eventBus = node.haServer.websocket.eventBus;
+            }
+            // 方式4: 检查 _events
+            else if (node.haServer._events) {
+                eventBus = node.haServer;
+            }
 
-            if (eventBus) {
+            if (eventBus && typeof eventBus.on === 'function') {
                 // 防止重复订阅
                 if (node.haSubscribed) return;
 
                 node.haEventHandler = (evt) => {
                     if (evt && evt.event_type === 'state_changed' && evt.data) {
+                        if (!node.haInputReceived) {
+                            node.haInputReceived = true;
+                            node.updateStatus();
+                        }
                         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})`);
+                // 尝试订阅不同的事件名
+                try {
+                    eventBus.on('ha_events:all', node.haEventHandler);
+                    node.haSubscribed = true;
+                    node.haInputReceived = true;
+                    node.log('[HA同步] 已成功订阅HA事件总线');
+                    node.updateStatus();
+                } catch (e1) {
+                    try {
+                        eventBus.on('state_changed', node.haEventHandler);
+                        node.haSubscribed = true;
+                        node.haInputReceived = true;
+                        node.log('[HA同步] 已成功订阅HA事件总线');
+                        node.updateStatus();
+                    } catch (e2) {
+                        // 静默失败
+                    }
                 }
-                
-                setTimeout(subscribeToHaEvents, 5000);
             }
+            // 事件总线不可用时不再重试，依赖 input 方式
         };
         
-        // 启动后立即开始静默尝试
-        subscribeToHaEvents();
+        // 延迟启动订阅尝试，给HA服务器时间初始化
+        setTimeout(subscribeToHaEvents, 3000);
 
         node.handleHaStateChange = function(entityId, newState, oldState) {
-            if (!newState) return;
+            if (!newState) {
+                return;
+            }
             
             const mappings = node.findMappingsByHa(entityId);
-            if (mappings.length === 0) return;
+            if (mappings.length === 0) {
+                return;
+            }
             
             const domain = node.getEntityDomain(entityId);
             const attrs = newState.attributes || {};
@@ -869,22 +982,6 @@ module.exports = function(RED) {
                 
                 node.log(`[Symi->HA] ${mapping.symiName || mapping.symiMac} -> ${mapping.haEntityId}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
-                // 仅输出到debug，不再重复send
-                /*
-                node.send({
-                    topic: 'ha-sync/symi-to-ha',
-                    payload: {
-                        direction: 'Symi→HA',
-                        symiMac: mapping.symiMac,
-                        symiKey: mapping.symiKey,
-                        haEntityId: mapping.haEntityId,
-                        syncType: syncData.type,
-                        value: syncData.value,
-                        timestamp: Date.now()
-                    }
-                });
-                */
-                
             } catch (err) {
                 node.error(`[Symi->HA] 调用失败: ${err.message}`);
             }
@@ -895,7 +992,14 @@ module.exports = function(RED) {
             const { mapping, syncData, key } = cmd;
             node.recordSyncTime('ha-to-symi', key);
             
-            const device = gateway.getDevice(mapping.symiMac);
+            // 动态获取gateway（可能在初始化后才可用）
+            const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
+            if (!currentGateway) {
+                node.warn(`[HA->Symi] 网关未就绪，无法控制设备`);
+                return;
+            }
+            
+            const device = currentGateway.getDevice(mapping.symiMac);
             if (!device) {
                 node.warn(`[HA->Symi] 设备未找到: ${mapping.symiMac}`);
                 return;
@@ -961,7 +1065,7 @@ module.exports = function(RED) {
                         return;
                 }
                 
-                await gateway.sendControl(networkAddr, attrType, param);
+                await currentGateway.sendControl(networkAddr, attrType, param);
                 
                 node.log(`[HA->Symi] ${mapping.haEntityId} -> ${device.name || mapping.symiMac}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
@@ -975,6 +1079,13 @@ module.exports = function(RED) {
             const { mapping, syncData } = cmd;
             const subType = mapping.symiKey;
             
+            // 动态获取gateway
+            const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
+            if (!currentGateway) {
+                node.warn(`[HA->Symi] 网关未就绪，无法控制三合一设备`);
+                return;
+            }
+            
             try {
                 let attrType, param;
                 
@@ -1030,7 +1141,7 @@ module.exports = function(RED) {
                 }
                 
                 if (attrType && param) {
-                    await gateway.sendControl(networkAddr, attrType, param);
+                    await currentGateway.sendControl(networkAddr, attrType, param);
                     node.log(`[HA->Symi] ${mapping.haEntityId} -> ${mapping.symiName}(${subType}): ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 }
                 

package/package.json

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