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

package/nodes/symi-ha-sync.js

@@ -1,6 +1,19 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.3
+ * 版本: 1.8.5
+ * 
+ * v1.8.5 更新:
+ * - 使用通用 SyncUtils 类统一防环路逻辑
+ * - 添加 StateCache 状态缓存，避免重复同步
+ * - 优化三合一面板同步逻辑
+ * 
+ * v1.8.4 更新:
+ * - 修复HA state_changed事件解析，支持更多消息格式
+ * - 优化窗帘同步：动作命令直接同步，位置只在非运动状态同步
+ * - 优化空调同步：只在开关状态真正变化时同步，避免off->off无效日志
+ * - 优化调光同步：HA发起调光时忽略Mesh步进反馈
+ * - 增加状态变化检测，无变化时跳过处理
+ * - 过滤sensor类型实体，避免不必要的处理
  * 
  * 支持的实体类型和属性：
  * - light: on/off, brightness (0-255)
@@ -12,6 +25,7 @@
 
 module.exports = function(RED) {
     const axios = require('axios');
+    const { SyncUtils, StateCache, COVER_TIMEOUT, BRIGHTNESS_TIMEOUT } = require('../lib/sync-utils');
     
     // 常量定义
     const LOOP_PREVENTION_MS = 2000;  // 防死循环时间窗口
@@ -21,11 +35,11 @@ module.exports = function(RED) {
     const TIMESTAMP_EXPIRE_MS = 60000;
     
     // 窗帘专用常量
-    const COVER_LOOP_PREVENTION_MS = 30000; // 30秒防死循环
+    const COVER_LOOP_PREVENTION_MS = COVER_TIMEOUT; // 30秒防死循环
     const COVER_DEBOUNCE_MS = 1500;         // 1.5秒防抖
     
     // 调光专用常量
-    const BRIGHTNESS_DEBOUNCE_MS = 800;     // 0.8秒防抖，过滤步进过程
+    const BRIGHTNESS_DEBOUNCE_MS = BRIGHTNESS_TIMEOUT;     // 0.8秒防抖，过滤步进过程
 
     // Mesh属性类型
     const ATTR_SWITCH = 0x02;
@@ -60,6 +74,16 @@ module.exports = function(RED) {
         node.mqttNode = RED.nodes.getNode(config.mqttConfig);
         node.haServer = RED.nodes.getNode(config.haServer);
         
+        // 初始化通用同步工具
+        node.syncUtils = new SyncUtils({
+            defaultTimeout: LOOP_PREVENTION_MS,
+            coverTimeout: COVER_LOOP_PREVENTION_MS,
+            brightnessTimeout: BRIGHTNESS_DEBOUNCE_MS
+        });
+        
+        // 初始化状态缓存（用于三合一面板细粒度状态对比）
+        node.stateCache = new StateCache(node.context(), 'ha_sync_state_cache');
+        
         // 解析映射配置
         try {
             const rawMappings = JSON.parse(config.mappings || '[]');
@@ -177,25 +201,16 @@ module.exports = function(RED) {
             }
         }, CLEANUP_INTERVAL_MS);
 
-        // 防死循环检查 - 双向时间戳检查
+        // 防死循环检查 - 使用通用 SyncUtils
         node.shouldPreventSync = function(direction, key) {
-            const now = Date.now();
-            if (direction === 'symi-to-ha') {
-                const lastHaTime = node.lastHaToSymi[key] || 0;
-                return (now - lastHaTime) < LOOP_PREVENTION_MS;
-            } else {
-                const lastSymiTime = node.lastSymiToHa[key] || 0;
-                return (now - lastSymiTime) < LOOP_PREVENTION_MS;
-            }
+            // 转换方向名称以匹配 SyncUtils 的格式
+            const syncDirection = direction === 'symi-to-ha' ? 'mesh-to-target' : 'target-to-mesh';
+            return node.syncUtils.shouldPreventSync(syncDirection, key);
         };
 
         node.recordSyncTime = function(direction, key) {
-            const now = Date.now();
-            if (direction === 'symi-to-ha') {
-                node.lastSymiToHa[key] = now;
-            } else {
-                node.lastHaToSymi[key] = now;
-            }
+            const syncDirection = direction === 'symi-to-ha' ? 'mesh-to-target' : 'target-to-mesh';
+            node.syncUtils.recordSyncTime(syncDirection, key);
         };
 
         node.sleep = function(ms) {
@@ -221,17 +236,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)
@@ -296,18 +321,35 @@ module.exports = function(RED) {
                     // 支持返回数组（用于三合一同时同步多个属性）
                     const syncDataList = Array.isArray(syncData) ? syncData : [syncData];
                     
-                    syncDataList.forEach(data => {
-                        if (node.shouldPreventSync('symi-to-ha', loopKey)) {
+                    syncDataList.forEach(async data => {
+                        // 窗帘关键动作：开、关、停
+                        const isImmediateAction = domain === 'cover' && 
+                            (data.type === 'curtain_action' || data.type === 'curtain_stop');
+                        
+                        // 窗帘位置同步（普通）
+                        const isCoverPos = domain === 'cover' && data.type === 'position';
+                        
+                        if (!isImmediateAction && !isCoverPos && node.shouldPreventSync('symi-to-ha', loopKey)) {
                             node.debug(`[Symi->HA] 跳过(防死循环): ${loopKey} ${data.type}`);
                             return;
                         }
                         
-                        node.queueCommand({
+                        const cmd = {
                             direction: 'symi-to-ha',
                             mapping: mapping,
                             syncData: data,
-                            key: loopKey
-                        });
+                            key: loopKey,
+                            skipLoopCheck: isImmediateAction || isCoverPos
+                        };
+
+                        // 窗帘关键动作：绕过队列，立即执行
+                        if (isImmediateAction) {
+                            node.debug(`[Symi->HA] 窗帘关键动作，立即同步: ${data.type}=${data.value}`);
+                            node.syncSymiToHa(cmd); // 异步执行但不排队
+                            return;
+                        }
+                        
+                        node.queueCommand(cmd);
                     });
                 }
             });
@@ -316,79 +358,54 @@ module.exports = function(RED) {
         // 处理三合一状态变化
         node.handleThreeInOneChange = function(device, mapping, state, attrType) {
             const subType = mapping.symiKey; // 'aircon', 'fresh_air', 'floor_heating'
+            const mac = device.macAddress.toLowerCase().replace(/:/g, '');
+            const changedData = [];
             
-            // 1. 空调部分 (通常通过0x94或标准温控指令更新)
-            if (subType === 'aircon') {
-                // 如果是标准温控属性更新，已经在switch case中处理了
-                // 这里主要处理0x94带来的全量更新
-                if (attrType === ATTR_THREE_IN_ONE) {
-                    // 此时state已经包含了所有更新
-                    // 需要检查哪些属性变了，但这里只能返回一个syncData
-                    // 我们可以返回一个特殊对象，或者分别检查
-                    // 为简化，这里假设HA端会处理部分更新，或者我们按优先级返回
-                    
-                    // 检查开关
-                    if (state.climateSwitch !== undefined) {
-                         // 注意：这里需要比对旧状态，但在handleSymiStateChange中难以获取旧状态
-                         // 我们可以利用node.queueCommand的去重机制，发送所有可能的状态
-                         // 但这样会产生大量流量。
-                         // 实际上DeviceManager触发事件时，如果是0x94，是全量更新。
-                         // 我们可以只处理核心属性。
-                         // 更好的方式是：在device-manager中，0x94更新会触发一次事件。
-                         // 这里我们返回一个复合对象，或者由上层逻辑拆分。
-                         // 由于syncData只能是一个对象，我们优先同步开关，然后是模式/温度
-                    }
-                }
-                // 由于0x94更新时，device-manager已经更新了state
-                // 我们可以直接从state读取当前值
+            // 辅助函数：检查属性是否变化，使用细粒度缓存key
+            const checkAndCacheProperty = (property, value, syncData) => {
+                if (value === undefined) return;
+                
+                // 细粒度缓存key: mac_subEntity_property
+                const cacheKey = `${mac}_${subType}_${property}`;
                 
-                // 构造空调状态
-                // 这里我们可能需要多次调用queueCommand，但handle函数只能返回一个
-                // 解决方案：handleSymiStateChange支持返回数组
-                return [
-                    { type: 'switch', value: state.climateSwitch },
-                    { type: 'temperature', value: state.targetTemp },
-                    { type: 'hvac_mode', value: AC_MODE_TO_HA[state.climateMode] || 'off', meshValue: state.climateMode },
-                    { type: 'fan_mode', value: FAN_MODE_TO_HA[state.fanMode] || 'auto', meshValue: state.fanMode }
-                ];
+                // 检查是否有变化
+                if (node.stateCache.hasChanged(cacheKey, value)) {
+                    node.stateCache.update(cacheKey, value);
+                    changedData.push(syncData);
+                    node.debug(`[三合一] ${subType}.${property} 变化: ${value}`);
+                }
+            };
+            
+            // 1. 空调部分
+            if (subType === 'aircon') {
+                checkAndCacheProperty('switch', state.climateSwitch, 
+                    { type: 'switch', value: state.climateSwitch });
+                checkAndCacheProperty('temperature', state.targetTemp, 
+                    { type: 'temperature', value: state.targetTemp });
+                checkAndCacheProperty('mode', state.climateMode, 
+                    { type: 'hvac_mode', value: AC_MODE_TO_HA[state.climateMode] || 'off', meshValue: state.climateMode });
+                checkAndCacheProperty('fanSpeed', state.fanMode, 
+                    { type: 'fan_mode', value: FAN_MODE_TO_HA[state.fanMode] || 'auto', meshValue: state.fanMode });
             }
             
             // 2. 新风部分
-            if (subType === 'fresh_air') {
-                // 新风开关 (0x68或0x94)
-                if (attrType === ATTR_FRESH_AIR_SWITCH || attrType === ATTR_THREE_IN_ONE) {
-                    if (state.freshAirSwitch !== undefined) {
-                        return { type: 'switch', value: state.freshAirSwitch };
-                    }
-                }
-                // 新风风速 (0x6A或0x94)
-                if (attrType === ATTR_FRESH_AIR_SPEED || attrType === ATTR_THREE_IN_ONE) {
-                    if (state.freshAirSpeed !== undefined) {
-                        return { type: 'fan_mode', value: FAN_MODE_TO_HA[state.freshAirSpeed] || 'auto', meshValue: state.freshAirSpeed };
-                    }
-                }
-                // 新风模式 (0x69或0x94)
-                // 目前HA Fan实体通常只支持on/off和speed，mode可能不支持或映射到preset_mode
-                // 暂时忽略模式，或视需求添加
+            else if (subType === 'fresh_air') {
+                checkAndCacheProperty('switch', state.freshAirSwitch, 
+                    { type: 'switch', value: state.freshAirSwitch });
+                checkAndCacheProperty('speed', state.freshAirSpeed, 
+                    { type: 'fan_mode', value: FAN_MODE_TO_HA[state.freshAirSpeed] || 'auto', meshValue: state.freshAirSpeed });
             }
             
             // 3. 地暖部分
-            if (subType === 'floor_heating') {
-                // 地暖开关 (0x6B或0x94)
-                if (attrType === ATTR_FLOOR_HEATING_SWITCH || attrType === ATTR_THREE_IN_ONE) {
-                    if (state.floorHeatingSwitch !== undefined) {
-                        return { type: 'switch', value: state.floorHeatingSwitch };
-                    }
-                }
-                // 地暖温度 (0x6C或0x94)
-                if (attrType === ATTR_FLOOR_HEATING_TEMP || attrType === ATTR_THREE_IN_ONE) {
-                    if (state.floorHeatingTemp !== undefined) {
-                        return { type: 'temperature', value: state.floorHeatingTemp };
-                    }
-                }
+            else if (subType === 'floor_heating') {
+                checkAndCacheProperty('switch', state.floorHeatingSwitch, 
+                    { type: 'switch', value: state.floorHeatingSwitch });
+                checkAndCacheProperty('temperature', state.floorHeatingTemp, 
+                    { type: 'temperature', value: state.floorHeatingTemp });
             }
             
-            return null;
+            // 只返回真正变化的属性
+            return changedData.length > 0 ? changedData : null;
         };
 
         // 处理开关状态变化
@@ -451,65 +468,77 @@ module.exports = function(RED) {
             return null;  // 不立即同步，由定时器处理
         };
 
-        // 处理窗帘变化（带防抖，避免步进反馈干扰）
+        // 处理窗帘变化 - 谁发起控制就只听谁的命令
+        // Mesh控制时只同步最终位置，忽略过程中的实时反馈
         node.handleCurtainChange = function(device, mapping, state, attrType) {
             const domain = node.getEntityDomain(mapping.haEntityId);
             if (domain !== 'cover') return null;
             
             const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
-            
-            // 检查是否是HA发起的运动，如果是则忽略Mesh的位置反馈（步进码）
-            if (node.coverMoving[loopKey] && node.coverMoving[loopKey].direction === 'ha') {
-                const elapsed = Date.now() - node.coverMoving[loopKey].startTime;
-                if (elapsed < COVER_LOOP_PREVENTION_MS) {
-                    node.debug(`[Symi->HA] 窗帘忽略(HA发起运动中): ${loopKey}`);
-                    return null;  // 忽略HA发起运动期间的Mesh反馈
-                } else {
-                    delete node.coverMoving[loopKey];  // 超时清理
-                }
+            const now = Date.now();
+
+            // 检查控制锁定时长，超过40秒强制释放（针对无限位模块或丢包情况）
+            if (node.coverMoving[loopKey] && (now - node.coverMoving[loopKey].startTime > 40000)) {
+                node.log(`[Symi->HA] 窗帘控制锁定超时(40s)，针对无限位模块强制释放: ${loopKey}`);
+                delete node.coverMoving[loopKey];
             }
+
+            // 获取动作状态
+            const action = state.curtainAction || device.state.curtainAction;
             
-            // 窗帘位置变化 - 使用防抖，只同步最终位置
-            if (attrType === ATTR_CURTAIN_POSITION) {
-                const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
-                if (position === undefined) return null;
-                
-                // 防抖处理：取消之前的定时器，设置新的
-                const debounceKey = `curtain_${mapping.symiMac}_${mapping.symiKey}`;
-                if (node.pendingDebounce[debounceKey]) {
-                    clearTimeout(node.pendingDebounce[debounceKey]);
+            // 1. 处理运行状态变化 (ATTR_CURTAIN_STATUS)
+            if (attrType === ATTR_CURTAIN_STATUS) {
+                if (action === 'opening' || action === 'closing') {
+                    // 如果是由HA发起的控制，Mesh反馈正在运行是正常的，继续保持HA控制权
+                    if (node.coverMoving[loopKey] && node.coverMoving[loopKey].direction === 'ha') {
+                        node.debug(`[Symi->HA] 窗帘反馈正在运行(HA控制中): ${action}`);
+                        return null;
+                    }
+                    
+                    // 强制同步：无论当前是否有锁定，只要收到 opening/closing 且当前状态不是对应动作，就触发一次同步
+                    const currentAction = node.coverMoving[loopKey] ? node.coverMoving[loopKey].action : null;
+                    if (currentAction !== action) {
+                        node.log(`[Symi->HA] 窗帘由Mesh发起动作: ${action}`);
+                        node.coverMoving[loopKey] = { 
+                            direction: 'symi', 
+                            startTime: now,
+                            action: action 
+                        };
+                        
+                        // 立即返回同步指令
+                        return { type: 'curtain_action', value: action === 'opening' ? 'open' : 'close' };
+                    }
+                    return null;
                 }
                 
-                // 标记Symi发起的运动
-                node.coverMoving[loopKey] = { direction: 'symi', startTime: Date.now(), targetPosition: position };
-                
-                // 延迟同步，等待位置稳定
-                node.pendingDebounce[debounceKey] = setTimeout(() => {
-                    delete node.pendingDebounce[debounceKey];
-                    // 运动结束，清理状态
+                if (action === 'stopped') {
+                    node.log(`[Symi->HA] 窗帘已停止，释放控制权: ${loopKey}`);
                     delete node.coverMoving[loopKey];
                     
-                    // 直接入队，跳过常规防死循环检查（窗帘有专门的运动状态跟踪）
-                    node.queueCommand({
-                        direction: 'symi-to-ha',
-                        mapping: mapping,
-                        syncData: { type: 'position', value: position },
-                        key: loopKey,
-                        skipLoopCheck: true
-                    });
-                }, COVER_DEBOUNCE_MS);
-                
-                return null;  // 不立即同步
+                    // 停止后同步一次最终位置
+                    const finalPos = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
+                    if (finalPos !== undefined) {
+                        node.debug(`[Symi->HA] 同步最终位置: ${finalPos}%`);
+                        return { type: 'position', value: finalPos };
+                    }
+                }
+                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' };
+            // 2. 处理位置变化 (ATTR_CURTAIN_POSITION)
+            if (attrType === ATTR_CURTAIN_POSITION) {
+                const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
+                if (position === undefined) return null;
+
+                // 核心需求：忽略过程中的实时反馈指令
+                // 如果当前有任何控制方向的锁定（正在移动中），则忽略位置反馈
+                if (node.coverMoving[loopKey]) {
+                    node.debug(`[Symi->HA] 忽略移动中的实时位置反馈: ${position}%`);
+                    return null;
                 }
+
+                // 没有移动锁定时，允许同步（例如初始同步或查询返回）
+                return { type: 'position', value: position };
             }
             
             return null;
@@ -556,6 +585,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 +601,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 +644,53 @@ module.exports = function(RED) {
                 newState = msg.payload;
                 oldState = null;
             }
+            // 格式6: call_service 事件 - 专门处理窗帘控制，解决状态反馈慢的问题
+            else if (msg.payload && msg.payload.event_type === 'call_service') {
+                const event = msg.payload.event;
+                if (event && event.domain === 'cover' && event.service_data && event.service_data.entity_id) {
+                    const entityId = event.service_data.entity_id;
+                    const service = event.service;
+                    
+                    node.log(`[HA] 捕获到窗帘服务调用: ${service} -> ${entityId}`);
+                    
+                    const mappings = node.findMappingsByHa(entityId);
+                    if (mappings.length > 0) {
+                        const now = Date.now();
+                        mappings.forEach(mapping => {
+                            const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                            let syncData = null;
+                            
+                            if (service === 'open_cover') {
+                                node.coverMoving[loopKey] = { direction: 'ha', startTime: now };
+                                syncData = { type: 'curtain_action', value: 1 };
+                            } else if (service === 'close_cover') {
+                                node.coverMoving[loopKey] = { direction: 'ha', startTime: now };
+                                syncData = { type: 'curtain_action', value: 2 };
+                            } else if (service === 'stop_cover') {
+                                delete node.coverMoving[loopKey];
+                                syncData = { type: 'curtain_stop', value: 3 };
+                            } else if (service === 'set_cover_position') {
+                                const pos = event.service_data.position;
+                                if (pos !== undefined) {
+                                    node.coverMoving[loopKey] = { direction: 'ha', startTime: now };
+                                    syncData = { type: 'position', value: pos };
+                                }
+                            }
+                            
+                            if (syncData) {
+                                node.queueCommand({
+                                    direction: 'ha-to-symi',
+                                    mapping: mapping,
+                                    syncData: syncData,
+                                    key: loopKey,
+                                    skipLoopCheck: true
+                                });
+                            }
+                        });
+                    }
+                }
+                return;
+            }
             
             // 过滤非 state_changed 事件和无效数据
             if (!entityId || !newState) {
@@ -605,14 +702,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 +812,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 || {}) : {};
@@ -739,79 +891,82 @@ module.exports = function(RED) {
                         
                     case 'cover':
                         const coverLoopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
-                        
-                        // 检查是否是Symi发起的运动，如果是则忽略HA的位置反馈
-                        if (node.coverMoving[coverLoopKey] && node.coverMoving[coverLoopKey].direction === 'symi') {
-                            const elapsed = Date.now() - node.coverMoving[coverLoopKey].startTime;
-                            if (elapsed < COVER_LOOP_PREVENTION_MS) {
-                                node.debug(`[HA->Symi] 窗帘忽略(Symi发起运动中): ${coverLoopKey}`);
-                                break;  // 忽略Symi发起运动期间的HA反馈
-                            }
+                        const now = Date.now();
+
+                        // 检查锁定时长，超过40秒强制释放（针对无限位模块）
+                        if (node.coverMoving[coverLoopKey] && (now - node.coverMoving[coverLoopKey].startTime > 40000)) {
+                            node.log(`[HA->Symi] 窗帘控制锁定超时(40s)，强制释放: ${coverLoopKey}`);
+                            delete node.coverMoving[coverLoopKey];
                         }
+
+                        // 1. 处理位置变化 (用户拖动滑块)
+                        const hasPositionChange = attrs.current_position !== undefined && 
+                            (!oldState || oldAttrs.current_position !== attrs.current_position);
                         
-                        // 运动中状态(opening/closing)不同步位置，避免步进反馈干扰
-                        if (newState.state === 'opening' || newState.state === 'closing') {
-                            node.debug(`[HA->Symi] 窗帘运动中，跳过位置同步: ${newState.state}`);
+                        if (hasPositionChange) {
+                            // HA 始终有控制优先权
+                            node.log(`[HA->Symi] 窗帘位置控制: ${attrs.current_position}`);
+                            node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: now };
+                            syncDataList.push({ type: 'position', value: attrs.current_position });
                             break;
                         }
                         
-                        // 窗帘位置变化 - 只在停止状态时同步
-                        if (attrs.current_position !== undefined) {
-                            if (!oldState || oldAttrs.current_position !== attrs.current_position) {
-                                // 标记HA发起的运动
-                                node.coverMoving[coverLoopKey] = { 
-                                    direction: 'ha', 
-                                    startTime: Date.now(), 
-                                    targetPosition: attrs.current_position 
-                                };
-                                syncDataList.push({ type: 'position', value: attrs.current_position });
-                            }
-                        }
-                        
-                        // 窗帘动作 - open/closed 状态变化
+                        // 2. 处理动作变化（用户点击按钮）
                         if (newState.state !== oldState?.state) {
-                            if (newState.state === 'open') {
-                                node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
-                                syncDataList.push({ type: 'curtain_action', value: 'open' });
-                            } else if (newState.state === 'closed') {
-                                node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
-                                syncDataList.push({ type: 'curtain_action', value: 'close' });
+                            if (newState.state === 'opening' || newState.state === 'closing') {
+                                node.log(`[HA->Symi] 窗帘动作控制: ${newState.state}`);
+                                node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: now };
+                                syncDataList.push({ type: 'curtain_action', value: newState.state === 'opening' ? 1 : 2 });
+                            } else if (newState.state === 'idle' || newState.state === 'stopped') {
+                                // 停止指令
+                                node.log(`[HA->Symi] 窗帘停止控制`);
+                                delete node.coverMoving[coverLoopKey];
+                                syncDataList.push({ type: 'curtain_stop', value: 3 });
                             }
                         }
                         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,10 +1092,26 @@ 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':
                         service = 'stop_cover';
+                        // 刷新锁定状态，防止HA反馈
+                        const stopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                        node.coverMoving[stopKey] = { direction: 'symi', startTime: Date.now() };
                         break;
                         
                     case 'temperature':
@@ -970,7 +1141,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: {
@@ -1163,6 +1334,16 @@ module.exports = function(RED) {
             node.coverMoving = {};       // 清理窗帘运动状态
             node.brightnessMoving = {};  // 清理调光运动状态
             
+            // 清理 SyncUtils
+            if (node.syncUtils) {
+                node.syncUtils.destroy();
+            }
+            
+            // 清理 StateCache（三合一状态缓存）
+            if (node.stateCache) {
+                node.stateCache.clear();
+            }
+            
             if (gateway) {
                 gateway.removeListener('device-state-changed', node.handleSymiStateChange);
             }