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

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,50 @@ node-red-contrib-symi-mesh/
 - 无TODO/FIXME/HACK标记
 - 代码无重复，模块化设计
 
+## 更新日志
+
+### v1.8.4 (2026-01-06)
+
+**HA同步节点窗帘双向同步重大修复**：
+- 实现"谁发起控制就只听谁的命令"逻辑，彻底解决窗帘双向同步死循环问题
+- Mesh控制时：只同步位置到HA，不发送动作命令（HA根据位置自动更新状态）
+- HA控制时：发送动作/位置到Mesh，运动过程中忽略Mesh的所有反馈
+- 停止后延迟5秒释放控制权，确保延迟反馈也被正确过滤
+- 只处理HA的`opening`/`closing`状态（用户操作），忽略`open`/`closed`（状态反馈）
+
+**其他优化**：
+- 修复HA state_changed事件解析，支持更多消息格式变体
+- 优化空调同步逻辑：只在开关状态真正变化时同步，避免off->off无效日志
+- 优化调光同步逻辑：HA发起调光时忽略Mesh步进反馈，防止状态回弹
+- 增加状态变化检测：无变化时跳过处理，减少无效日志
+- 过滤sensor类型实体，避免不必要的处理
+
+**问题修复**：
+- 修复Mesh控制窗帘时HA反向发送命令导致窗帘停止的问题
+- 修复HA控制窗帘时Mesh反馈导致循环控制的问题
+- 修复窗帘打开命令被防死循环机制阻止的问题
+- 修复空调off->off重复日志的问题
+
+### 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 +1662,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 +1719,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 +1730,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

@@ -202,7 +202,7 @@
                     });
                 } else {
                     // 多路开关
-                    var channels = parseInt(device ? (device.channels || 1) : (savedChannels || 1)) || 1;
+                    var channels = device ? (device.channels || 1) : (savedChannels || 1);
                     for (var i = 1; i <= channels; i++) {
                         var sel = (i == selectedKey) ? ' selected' : '';
                         html += '<option value="' + i + '"' + sel + '>按键' + i + '</option>';

package/nodes/symi-ha-sync.js

@@ -1,6 +1,14 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.2
+ * 版本: 1.8.4
+ * 
+ * v1.8.4 更新:
+ * - 修复HA state_changed事件解析，支持更多消息格式
+ * - 优化窗帘同步：动作命令直接同步，位置只在非运动状态同步
+ * - 优化空调同步：只在开关状态真正变化时同步，避免off->off无效日志
+ * - 优化调光同步：HA发起调光时忽略Mesh步进反馈
+ * - 增加状态变化检测，无变化时跳过处理
+ * - 过滤sensor类型实体，避免不必要的处理
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -96,28 +104,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 +173,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);
 
         // 防死循环检查 - 双向时间戳检查
@@ -191,17 +229,27 @@ module.exports = function(RED) {
 
         // ========== 1. 监听Symi设备状态变化 (Symi -> HA) ==========
         node.handleSymiStateChange = function(eventData) {
-            if (!eventData.device || !eventData.device.macAddress) return;
+            if (!eventData.device || !eventData.device.macAddress) {
+                node.debug('[Symi->HA] 忽略: 无效的设备数据');
+                return;
+            }
             
             const device = eventData.device;
             const attrType = eventData.attrType;
             const state = eventData.state || {};
             
+            node.debug(`[Symi->HA] 设备状态变化: ${device.macAddress}, attrType=0x${attrType?.toString(16) || 'unknown'}, state=${JSON.stringify(state)}`);
+            
             // 遍历该设备的所有映射
             const deviceMappings = node.mappings.filter(m => 
                 m.symiMac.toLowerCase().replace(/:/g, '') === device.macAddress.toLowerCase().replace(/:/g, '')
             );
-            if (deviceMappings.length === 0) return;
+            if (deviceMappings.length === 0) {
+                node.debug(`[Symi->HA] 设备不在映射中: ${device.macAddress}`);
+                return;
+            }
+            
+            node.debug(`[Symi->HA] 找到 ${deviceMappings.length} 个映射`);
             
             deviceMappings.forEach(mapping => {
                 // 检查同步模式 (0:双向, 1:Symi->HA, 2:HA->Symi)
@@ -267,7 +315,11 @@ module.exports = function(RED) {
                     const syncDataList = Array.isArray(syncData) ? syncData : [syncData];
                     
                     syncDataList.forEach(data => {
-                        if (node.shouldPreventSync('symi-to-ha', loopKey)) {
+                        // 窗帘使用专门的coverMoving状态跟踪，跳过常规防死循环检查
+                        const isCoverAction = domain === 'cover' && 
+                            (data.type === 'curtain_action' || data.type === 'curtain_stop' || data.type === 'position');
+                        
+                        if (!isCoverAction && node.shouldPreventSync('symi-to-ha', loopKey)) {
                             node.debug(`[Symi->HA] 跳过(防死循环): ${loopKey} ${data.type}`);
                             return;
                         }
@@ -276,7 +328,8 @@ module.exports = function(RED) {
                             direction: 'symi-to-ha',
                             mapping: mapping,
                             syncData: data,
-                            key: loopKey
+                            key: loopKey,
+                            skipLoopCheck: isCoverAction  // 窗帘跳过常规防死循环检查
                         });
                     });
                 }
@@ -421,65 +474,58 @@ module.exports = function(RED) {
             return null;  // 不立即同步，由定时器处理
         };
 
-        // 处理窗帘变化（带防抖，避免步进反馈干扰）
+        // 处理窗帘变化 - 谁发起控制就只听谁的命令
+        // Mesh控制时只同步位置，不同步动作（HA会根据位置自动更新状态）
         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的位置反馈（步进码）
+            // 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];  // 超时清理
+                const action = state.curtainAction || device.state.curtainAction;
+                if (action === 'stopped') {
+                    // Mesh停止了，延迟清理HA控制标记
+                    node.log(`[Symi->HA] 窗帘stopped, 释放HA控制权`);
+                    setTimeout(() => {
+                        delete node.coverMoving[loopKey];
+                    }, 5000);
                 }
+                node.debug(`[Symi->HA] 窗帘忽略(HA控制中): ${JSON.stringify(state)}`);
+                return null;
             }
             
-            // 窗帘位置变化 - 使用防抖，只同步最终位置
-            if (attrType === ATTR_CURTAIN_POSITION) {
-                const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
-                if (position === undefined) return null;
+            // 窗帘运行状态变化 - 只标记控制方向，不发送动作到HA
+            if (attrType === ATTR_CURTAIN_STATUS) {
+                const action = state.curtainAction || device.state.curtainAction;
                 
-                // 防抖处理：取消之前的定时器，设置新的
-                const debounceKey = `curtain_${mapping.symiMac}_${mapping.symiKey}`;
-                if (node.pendingDebounce[debounceKey]) {
-                    clearTimeout(node.pendingDebounce[debounceKey]);
+                if (action === 'opening' || action === 'closing') {
+                    // 标记Mesh正在控制，用于过滤HA的状态反馈
+                    node.log(`[Symi->HA] 窗帘开始${action}, 标记Symi控制`);
+                    node.coverMoving[loopKey] = { direction: 'symi', startTime: Date.now() };
+                    // 不发送动作到HA，只同步位置
+                    return null;
                 }
                 
-                // 标记Symi发起的运动
-                node.coverMoving[loopKey] = { direction: 'symi', startTime: Date.now(), targetPosition: position };
-                
-                // 延迟同步，等待位置稳定
-                node.pendingDebounce[debounceKey] = setTimeout(() => {
-                    delete node.pendingDebounce[debounceKey];
-                    // 运动结束，清理状态
-                    delete node.coverMoving[loopKey];
-                    
-                    // 直接入队，跳过常规防死循环检查（窗帘有专门的运动状态跟踪）
-                    node.queueCommand({
-                        direction: 'symi-to-ha',
-                        mapping: mapping,
-                        syncData: { type: 'position', value: position },
-                        key: loopKey,
-                        skipLoopCheck: true
-                    });
-                }, COVER_DEBOUNCE_MS);
+                if (action === 'stopped') {
+                    // 停止后延迟5秒清理标记
+                    node.log(`[Symi->HA] 窗帘stopped, 释放Symi控制权`);
+                    setTimeout(() => {
+                        delete node.coverMoving[loopKey];
+                    }, 5000);
+                    return null;
+                }
                 
-                return null;  // 不立即同步
+                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' };
-                }
+            // 窗帘位置变化 - 同步位置到HA
+            if (attrType === ATTR_CURTAIN_POSITION) {
+                const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
+                if (position === undefined) return null;
+                
+                return { type: 'position', value: position };
             }
             
             return null;
@@ -510,74 +556,243 @@ 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输入，双向同步已启用');
+            }
+            
+            // 调试：记录收到的消息结构
+            if (msg.payload && msg.payload.event_type) {
+                node.debug(`[HA输入] event_type=${msg.payload.event_type}, entity_id=${msg.payload.entity_id}, event=${msg.payload.event ? 'object' : 'null'}`);
+            }
+            
+            // 支持多种消息格式
+            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;
+                    // 如果 event 中也有 entity_id，优先使用（更可靠）
+                    if (msg.payload.event.entity_id) {
+                        entityId = msg.payload.event.entity_id;
+                    }
+                    // 调试：记录 event 对象的结构
+                    if (!newState) {
+                        node.debug(`[HA输入] event对象结构: ${JSON.stringify(Object.keys(msg.payload.event))}`);
+                    }
+                }
+                // 兼容格式：event.data 包含 new_state/old_state
+                if (!newState && msg.payload.event && msg.payload.event.data) {
+                    newState = msg.payload.event.data.new_state;
+                    oldState = msg.payload.event.data.old_state;
+                    if (msg.payload.event.data.entity_id) {
+                        entityId = msg.payload.event.data.entity_id;
+                    }
+                }
+            }
+            // 格式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;
+            }
+            // 格式6: call_service 事件 - 从 service_data 中提取 entity_id
+            else if (msg.payload && msg.payload.event_type === 'call_service') {
+                const event = msg.payload.event;
+                if (event && event.service_data && event.service_data.entity_id) {
+                    // call_service 事件需要特殊处理，我们需要等待后续的 state_changed 事件
+                    // 这里只记录日志，不直接处理
+                    node.debug(`[HA] call_service: ${event.domain}.${event.service} -> ${event.service_data.entity_id}`);
                 }
-            } 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);
+                return;  // call_service 事件不直接处理，等待 state_changed
             }
+            
+            // 过滤非 state_changed 事件和无效数据
+            if (!entityId || !newState) {
+                return;  // 静默忽略无法解析的消息
+            }
+            
+            // 过滤 event 类型的实体（如 event.xxx_click_e_xxx），这些不需要同步
+            if (entityId.startsWith('event.')) {
+                return;
+            }
+            
+            // 过滤 sensor 类型的实体（传感器不需要同步控制）
+            if (entityId.startsWith('sensor.')) {
+                return;
+            }
+            
+            // 检查是否在映射列表中
+            const mappings = node.findMappingsByHa(entityId);
+            if (mappings.length === 0) {
+                return;  // 不在映射中的实体静默忽略
+            }
+            
+            // 检查状态是否有变化（避免 off -> off 这种无效处理）
+            const hasStateChange = !oldState || newState.state !== oldState.state;
+            const attrs = newState.attributes || {};
+            const oldAttrs = oldState ? (oldState.attributes || {}) : {};
+            const domain = entityId.split('.')[0];
+            
+            // 根据实体类型检查相关属性变化
+            let hasAttrChange = false;
+            if (domain === 'light') {
+                hasAttrChange = attrs.brightness !== oldAttrs.brightness;
+            } else if (domain === 'cover') {
+                // cover需要检查位置变化，状态变化已经在hasStateChange中检查了
+                hasAttrChange = attrs.current_position !== oldAttrs.current_position;
+            } else if (domain === 'climate') {
+                hasAttrChange = attrs.temperature !== oldAttrs.temperature ||
+                    attrs.hvac_mode !== oldAttrs.hvac_mode ||
+                    attrs.fan_mode !== oldAttrs.fan_mode;
+            } else if (domain === 'fan') {
+                hasAttrChange = attrs.percentage !== oldAttrs.percentage ||
+                    attrs.preset_mode !== oldAttrs.preset_mode;
+            }
+            
+            // 如果状态和属性都没变化，完全跳过
+            if (!hasStateChange && !hasAttrChange) {
+                return;
+            }
+            
+            // 不在这里打印日志，让handleHaStateChange内部处理
+            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) {
+                node.debug(`[HA->Symi] 忽略: ${entityId} newState为空`);
+                return;
+            }
+            
+            // 如果新旧状态完全相同，跳过处理（避免无效同步）
+            if (oldState && newState.state === oldState.state) {
+                const attrs = newState.attributes || {};
+                const oldAttrs = oldState.attributes || {};
+                // 检查关键属性是否有变化
+                const hasAttrChange = 
+                    attrs.brightness !== oldAttrs.brightness ||
+                    attrs.current_position !== oldAttrs.current_position ||
+                    attrs.temperature !== oldAttrs.temperature ||
+                    attrs.hvac_mode !== oldAttrs.hvac_mode ||
+                    attrs.fan_mode !== oldAttrs.fan_mode ||
+                    attrs.percentage !== oldAttrs.percentage;
+                
+                if (!hasAttrChange) {
+                    node.debug(`[HA->Symi] 忽略: ${entityId} 状态无变化`);
+                    return;
+                }
+            }
             
             const mappings = node.findMappingsByHa(entityId);
-            if (mappings.length === 0) return;
+            if (mappings.length === 0) {
+                // 不在映射中的实体静默忽略，但记录调试信息
+                node.debug(`[HA->Symi] 实体不在映射中: ${entityId}`);
+                return;
+            }
+            
+            node.debug(`[HA->Symi] 处理实体: ${entityId}, 找到 ${mappings.length} 个映射`);
             
             const domain = node.getEntityDomain(entityId);
             const attrs = newState.attributes || {};
@@ -627,78 +842,82 @@ module.exports = function(RED) {
                     case 'cover':
                         const coverLoopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
                         
-                        // 检查是否是Symi发起的运动，如果是则忽略HA的位置反馈
+                        // Mesh控制期间，完全忽略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}`);
+                            node.debug(`[HA->Symi] 窗帘忽略(Mesh控制中): ${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 });
-                            }
+                        // 检查是否有位置变化（用户拖动滑块）
+                        const hasPositionChange = attrs.current_position !== undefined && 
+                            (!oldState || oldAttrs.current_position !== attrs.current_position);
+                        
+                        // 优先处理位置变化（用户拖动滑块）- 这是HA主动控制
+                        if (hasPositionChange) {
+                            node.log(`[HA->Symi] 窗帘位置: ${attrs.current_position}`);
+                            // 标记HA正在控制
+                            node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
+                            syncDataList.push({ type: 'position', value: attrs.current_position });
+                            break;
                         }
                         
-                        // 窗帘动作 - open/closed 状态变化
+                        // 动作变化 - 只处理opening/closing（用户点击按钮）
+                        // 不处理open/closed（这是状态反馈，不是用户操作）
                         if (newState.state !== oldState?.state) {
-                            if (newState.state === 'open') {
+                            if (newState.state === 'opening') {
+                                node.log(`[HA->Symi] 窗帘动作: open`);
                                 node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
                                 syncDataList.push({ type: 'curtain_action', value: 'open' });
-                            } else if (newState.state === 'closed') {
+                            } else if (newState.state === 'closing') {
+                                node.log(`[HA->Symi] 窗帘动作: close`);
                                 node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
                                 syncDataList.push({ type: 'curtain_action', value: 'close' });
                             }
+                            // open/closed 是最终状态，不是动作，不需要同步
                         }
                         break;
                         
                     case 'climate':
-                        // 开关状态
-                        if (!oldState || newState.state !== oldState.state) {
-                            const isOn = newState.state !== 'off' && newState.state !== 'unavailable';
-                            // 仅当状态从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 });
-                            }
+                        node.debug(`[HA->Symi] 空调状态: ${oldState?.state} -> ${newState.state}, 温度: ${attrs.temperature}, 模式: ${attrs.hvac_mode}, 风速: ${attrs.fan_mode}`);
+                        
+                        // 开关状态 - 只在状态真正变化时同步
+                        const isOn = newState.state !== 'off' && newState.state !== 'unavailable';
+                        const wasOn = oldState ? (oldState.state !== 'off' && oldState.state !== 'unavailable') : null;
+                        
+                        // 只有当开关状态真正变化时才同步（避免 off -> off 的无效同步）
+                        if (wasOn !== null && isOn !== wasOn) {
+                            node.debug(`[HA->Symi] 空调开关: ${wasOn} -> ${isOn}`);
+                            syncDataList.push({ type: 'switch', value: isOn });
                         }
+                        
                         // 目标温度
                         if (attrs.temperature !== undefined) {
                             if (!oldState || oldAttrs.temperature !== attrs.temperature) {
+                                node.debug(`[HA->Symi] 空调温度: ${oldAttrs.temperature} -> ${attrs.temperature}`);
                                 syncDataList.push({ type: 'temperature', value: Math.round(attrs.temperature) });
                             }
                         }
-                        // HVAC模式
-                        // 过滤掉off模式的变化，因为off已经由开关状态处理
-                        if (newState.state !== 'off' && (attrs.hvac_mode !== undefined || newState.state !== oldState?.state)) {
+                        
+                        // HVAC模式 - 只在非off状态时同步
+                        if (newState.state !== 'off' && newState.state !== 'unavailable') {
                             const hvacMode = attrs.hvac_mode || newState.state;
-                            if (hvacMode !== 'off' && (!oldState || (oldAttrs.hvac_mode || oldState.state) !== hvacMode)) {
+                            const oldHvacMode = oldAttrs.hvac_mode || oldState?.state;
+                            
+                            if (hvacMode !== 'off' && hvacMode !== oldHvacMode) {
                                 const meshMode = HA_TO_AC_MODE[hvacMode];
                                 if (meshMode !== undefined) {
+                                    node.debug(`[HA->Symi] 空调模式: ${oldHvacMode} -> ${hvacMode} (mesh: ${meshMode})`);
                                     syncDataList.push({ type: 'hvac_mode', value: meshMode });
                                 }
                             }
                         }
+                        
                         // 风速
                         if (attrs.fan_mode !== undefined) {
                             if (!oldState || oldAttrs.fan_mode !== attrs.fan_mode) {
                                 const meshFan = HA_TO_FAN_MODE[attrs.fan_mode];
                                 if (meshFan !== undefined) {
+                                    node.debug(`[HA->Symi] 空调风速: ${oldAttrs.fan_mode} -> ${attrs.fan_mode} (mesh: ${meshFan})`);
                                     syncDataList.push({ type: 'fan_mode', value: meshFan });
                                 }
                             }
@@ -824,6 +1043,19 @@ module.exports = function(RED) {
                     case 'position':
                         service = 'set_cover_position';
                         serviceData.position = syncData.value;
+                        // 刷新coverMoving状态，防止HA反馈被处理
+                        const posKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                        node.coverMoving[posKey] = { direction: 'symi', startTime: Date.now(), targetPosition: syncData.value };
+                        node.debug(`[Symi->HA] 窗帘位置同步，刷新coverMoving: ${posKey}`);
+                        break;
+                        
+                    case 'curtain_action':
+                        // open/close 动作 - 确保标记为Symi发起的运动
+                        service = syncData.value === 'open' ? 'open_cover' : 'close_cover';
+                        // 刷新coverMoving状态，防止HA反馈被处理
+                        const coverKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                        node.coverMoving[coverKey] = { direction: 'symi', startTime: Date.now() };
+                        node.debug(`[Symi->HA] 窗帘动作同步，刷新coverMoving: ${coverKey}`);
                         break;
                         
                     case 'curtain_stop':
@@ -857,7 +1089,7 @@ module.exports = function(RED) {
                         return;
                 }
                 
-                const serviceDomain = (syncData.type === 'position' || syncData.type === 'curtain_stop') ? 'cover' : domain;
+                const serviceDomain = (syncData.type === 'position' || syncData.type === 'curtain_stop' || syncData.type === 'curtain_action') ? 'cover' : domain;
                 
                 await axios.post(`${baseURL}/api/services/${serviceDomain}/${service}`, serviceData, {
                     headers: {
@@ -869,22 +1101,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 +1111,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 +1184,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 +1198,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 +1260,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.4",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {