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

package/README.md

@@ -1537,6 +1537,28 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### 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同步节点重大修复**：

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>';
@@ -477,44 +477,11 @@
     <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>
-    </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>
+        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置</li>
     </ul>
 
     <h3>支持的设备类型</h3>
@@ -523,15 +490,6 @@
         <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,14 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.3
+ * 版本: 1.8.4
+ * 
+ * v1.8.4 更新:
+ * - 修复HA state_changed事件解析，支持更多消息格式
+ * - 优化窗帘同步：动作命令直接同步，位置只在非运动状态同步
+ * - 优化空调同步：只在开关状态真正变化时同步，避免off->off无效日志
+ * - 优化调光同步：HA发起调光时忽略Mesh步进反馈
+ * - 增加状态变化检测，无变化时跳过处理
+ * - 过滤sensor类型实体，避免不必要的处理
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -221,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)
@@ -297,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;
                         }
@@ -306,7 +328,8 @@ module.exports = function(RED) {
                             direction: 'symi-to-ha',
                             mapping: mapping,
                             syncData: data,
-                            key: loopKey
+                            key: loopKey,
+                            skipLoopCheck: isCoverAction  // 窗帘跳过常规防死循环检查
                         });
                     });
                 }
@@ -451,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;
@@ -556,6 +572,11 @@ module.exports = function(RED) {
                 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;
             
@@ -567,6 +588,22 @@ module.exports = function(RED) {
                 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)
@@ -594,6 +631,16 @@ module.exports = function(RED) {
                 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}`);
+                }
+                return;  // call_service 事件不直接处理，等待 state_changed
+            }
             
             // 过滤非 state_changed 事件和无效数据
             if (!entityId || !newState) {
@@ -605,14 +652,45 @@ module.exports = function(RED) {
                 return;
             }
             
+            // 过滤 sensor 类型的实体（传感器不需要同步控制）
+            if (entityId.startsWith('sensor.')) {
+                return;
+            }
+            
             // 检查是否在映射列表中
             const mappings = node.findMappingsByHa(entityId);
             if (mappings.length === 0) {
                 return;  // 不在映射中的实体静默忽略
             }
             
-            // 只记录映射中的实体状态变化
-            node.log(`[HA->Symi] ${entityId}: ${oldState?.state || 'null'} -> ${newState.state}`);
+            // 检查状态是否有变化（避免 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);
         });
         
@@ -684,14 +762,38 @@ module.exports = function(RED) {
 
         node.handleHaStateChange = function(entityId, newState, oldState) {
             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) {
+                // 不在映射中的实体静默忽略，但记录调试信息
+                node.debug(`[HA->Symi] 实体不在映射中: ${entityId}`);
                 return;
             }
             
+            node.debug(`[HA->Symi] 处理实体: ${entityId}, 找到 ${mappings.length} 个映射`);
+            
             const domain = node.getEntityDomain(entityId);
             const attrs = newState.attributes || {};
             const oldAttrs = oldState ? (oldState.attributes || {}) : {};
@@ -740,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 });
                                 }
                             }
@@ -937,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':
@@ -970,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: {

package/package.json

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