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

package/nodes/symi-ha-sync.js

@@ -1,6 +1,11 @@
 /**
  * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
- * 版本: 1.8.4
+ * 版本: 1.8.5
+ * 
+ * v1.8.5 更新:
+ * - 使用通用 SyncUtils 类统一防环路逻辑
+ * - 添加 StateCache 状态缓存，避免重复同步
+ * - 优化三合一面板同步逻辑
  * 
  * v1.8.4 更新:
  * - 修复HA state_changed事件解析，支持更多消息格式
@@ -20,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;  // 防死循环时间窗口
@@ -29,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;
@@ -68,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 || '[]');
@@ -185,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) {
@@ -314,23 +321,35 @@ module.exports = function(RED) {
                     // 支持返回数组（用于三合一同时同步多个属性）
                     const syncDataList = Array.isArray(syncData) ? syncData : [syncData];
                     
-                    syncDataList.forEach(data => {
-                        // 窗帘使用专门的coverMoving状态跟踪，跳过常规防死循环检查
-                        const isCoverAction = domain === 'cover' && 
-                            (data.type === 'curtain_action' || data.type === 'curtain_stop' || data.type === 'position');
+                    syncDataList.forEach(async data => {
+                        // 窗帘关键动作：开、关、停
+                        const isImmediateAction = domain === 'cover' && 
+                            (data.type === 'curtain_action' || data.type === 'curtain_stop');
                         
-                        if (!isCoverAction && node.shouldPreventSync('symi-to-ha', loopKey)) {
+                        // 窗帘位置同步（普通）
+                        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,
-                            skipLoopCheck: isCoverAction  // 窗帘跳过常规防死循环检查
-                        });
+                            skipLoopCheck: isImmediateAction || isCoverPos
+                        };
+
+                        // 窗帘关键动作：绕过队列，立即执行
+                        if (isImmediateAction) {
+                            node.debug(`[Symi->HA] 窗帘关键动作，立即同步: ${data.type}=${data.value}`);
+                            node.syncSymiToHa(cmd); // 异步执行但不排队
+                            return;
+                        }
+                        
+                        node.queueCommand(cmd);
                     });
                 }
             });
@@ -339,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;
         };
 
         // 处理开关状态变化
@@ -475,56 +469,75 @@ module.exports = function(RED) {
         };
 
         // 处理窗帘变化 - 谁发起控制就只听谁的命令
-        // Mesh控制时只同步位置，不同步动作（HA会根据位置自动更新状态）
+        // 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 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;
+            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;
             
-            // 窗帘运行状态变化 - 只标记控制方向，不发送动作到HA
+            // 1. 处理运行状态变化 (ATTR_CURTAIN_STATUS)
             if (attrType === ATTR_CURTAIN_STATUS) {
-                const action = state.curtainAction || device.state.curtainAction;
-                
                 if (action === 'opening' || action === 'closing') {
-                    // 标记Mesh正在控制，用于过滤HA的状态反馈
-                    node.log(`[Symi->HA] 窗帘开始${action}, 标记Symi控制`);
-                    node.coverMoving[loopKey] = { direction: 'symi', startTime: Date.now() };
-                    // 不发送动作到HA，只同步位置
+                    // 如果是由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;
                 }
                 
                 if (action === 'stopped') {
-                    // 停止后延迟5秒清理标记
-                    node.log(`[Symi->HA] 窗帘stopped, 释放Symi控制权`);
-                    setTimeout(() => {
-                        delete node.coverMoving[loopKey];
-                    }, 5000);
-                    return null;
+                    node.log(`[Symi->HA] 窗帘已停止，释放控制权: ${loopKey}`);
+                    delete node.coverMoving[loopKey];
+                    
+                    // 停止后同步一次最终位置
+                    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;
             }
             
-            // 窗帘位置变化 - 同步位置到HA
+            // 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 };
             }
             
@@ -631,15 +644,52 @@ module.exports = function(RED) {
                 newState = msg.payload;
                 oldState = null;
             }
-            // 格式6: call_service 事件 - 从 service_data 中提取 entity_id
+            // 格式6: call_service 事件 - 专门处理窗帘控制，解决状态反馈慢的问题
             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}`);
+                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;  // call_service 事件不直接处理，等待 state_changed
+                return;
             }
             
             // 过滤非 state_changed 事件和无效数据
@@ -841,39 +891,38 @@ module.exports = function(RED) {
                         
                     case 'cover':
                         const coverLoopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
-                        
-                        // Mesh控制期间，完全忽略HA的所有消息
-                        if (node.coverMoving[coverLoopKey] && node.coverMoving[coverLoopKey].direction === 'symi') {
-                            node.debug(`[HA->Symi] 窗帘忽略(Mesh控制中): ${newState.state}`);
-                            break;
+                        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);
                         
-                        // 优先处理位置变化（用户拖动滑块）- 这是HA主动控制
                         if (hasPositionChange) {
-                            node.log(`[HA->Symi] 窗帘位置: ${attrs.current_position}`);
-                            // 标记HA正在控制
-                            node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: Date.now() };
+                            // HA 始终有控制优先权
+                            node.log(`[HA->Symi] 窗帘位置控制: ${attrs.current_position}`);
+                            node.coverMoving[coverLoopKey] = { direction: 'ha', startTime: now };
                             syncDataList.push({ type: 'position', value: attrs.current_position });
                             break;
                         }
                         
-                        // 动作变化 - 只处理opening/closing（用户点击按钮）
-                        // 不处理open/closed（这是状态反馈，不是用户操作）
+                        // 2. 处理动作变化（用户点击按钮）
                         if (newState.state !== oldState?.state) {
-                            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 === 'closing') {
-                                node.log(`[HA->Symi] 窗帘动作: close`);
-                                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 });
                             }
-                            // open/closed 是最终状态，不是动作，不需要同步
                         }
                         break;
                         
@@ -1060,6 +1109,9 @@ module.exports = function(RED) {
                         
                     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':
@@ -1282,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);
             }

package/nodes/symi-knx-bridge.html

@@ -17,6 +17,14 @@
         label: function() { return this.name || 'KNX桥接'; },
         oneditprepare: function() {
             const node = this;
+
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
+
             let mappings = [], devices = [], knxEntities = [];
             const typeLabels = {switch:'开关',light_mono:'单调',light_cct:'双调',light_rgb:'RGB',light_rgbcw:'RGBCW',cover:'窗帘',climate:'空调',fresh_air:'新风',floor_heating:'地暖'};
 

package/nodes/symi-knx-bridge.js

@@ -3,10 +3,15 @@
  * 支持开关、窗帘等设备的双向状态同步
  * 事件驱动架构，命令队列顺序处理，防死循环机制
  * 
- * 版本: 1.6.8
+ * 版本: 1.8.5
+ * 
+ * v1.8.5 更新:
+ * - 使用通用 SyncUtils 类统一防环路逻辑
+ * - 移除本地 LOOP_PREVENTION_MS 常量，使用 SyncUtils.getTimeoutForDevice()
  */
 
 module.exports = function(RED) {
+    const { SyncUtils, COVER_TIMEOUT, BRIGHTNESS_TIMEOUT, DEFAULT_TIMEOUT } = require('../lib/sync-utils');
     
     // 设备类型配置
     const DEVICE_TYPES = {
@@ -147,12 +152,16 @@ module.exports = function(RED) {
         node.lastSyncTime = 0;
         node.stateCache = {};           // Mesh设备状态缓存
         node.knxStateCache = {};        // KNX设备状态缓存
-        node.lastMeshToKnx = {};        // 记录Mesh->KNX发送时间，防止回环
-        node.lastKnxToMesh = {};        // 记录KNX->Mesh发送时间，防止回环
         node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间，防止自己发的命令又被处理
         
-        // 防死循环参数
-        const LOOP_PREVENTION_MS = 800;   // 800ms内不处理反向同步，防止回环
+        // 初始化通用同步工具类
+        node.syncUtils = new SyncUtils({
+            defaultTimeout: DEFAULT_TIMEOUT,
+            coverTimeout: COVER_TIMEOUT,
+            brightnessTimeout: BRIGHTNESS_TIMEOUT
+        });
+        
+        // 防死循环参数（使用 SyncUtils 的超时配置）
         const DEBOUNCE_MS = 100;          // 100ms防抖
         const MAX_QUEUE_SIZE = 100;       // 最大队列大小
         const COVER_CONTROL_LOCK_MS = 3000;  // 窗帘/调光控制锁定3秒（只忽略过程反馈，不长期锁定）
@@ -226,26 +235,17 @@ module.exports = function(RED) {
             return str;
         };
 
-        // 检查是否应该阻止同步（防死循环）
+        // 检查是否应该阻止同步（防死循环）- 使用通用 SyncUtils
         node.shouldPreventSync = function(direction, key) {
-            const now = Date.now();
-            if (direction === 'mesh-to-knx') {
-                const lastKnxTime = node.lastKnxToMesh[key] || 0;
-                return (now - lastKnxTime) < LOOP_PREVENTION_MS;
-            } else {
-                const lastMeshTime = node.lastMeshToKnx[key] || 0;
-                return (now - lastMeshTime) < LOOP_PREVENTION_MS;
-            }
+            // 转换方向名称以匹配 SyncUtils 的格式
+            const syncDirection = direction === 'mesh-to-knx' ? 'mesh-to-target' : 'target-to-mesh';
+            return node.syncUtils.shouldPreventSync(syncDirection, key);
         };
 
-        // 记录同步时间（用于防死循环）
+        // 记录同步时间（用于防死循环）- 使用通用 SyncUtils
         node.recordSyncTime = function(direction, key) {
-            const now = Date.now();
-            if (direction === 'mesh-to-knx') {
-                node.lastMeshToKnx[key] = now;
-            } else {
-                node.lastKnxToMesh[key] = now;
-            }
+            const syncDirection = direction === 'mesh-to-knx' ? 'mesh-to-target' : 'target-to-mesh';
+            node.syncUtils.recordSyncTime(syncDirection, key);
         };
 
         // 延时函数
@@ -953,7 +953,7 @@ module.exports = function(RED) {
             
             // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
             const lastSentTime = node.lastKnxAddrSent[groupAddr] || 0;
-            if (Date.now() - lastSentTime < LOOP_PREVENTION_MS) {
+            if (Date.now() - lastSentTime < DEFAULT_TIMEOUT) {
                 node.debug(`[KNX输入] 跳过(自己发的): ${groupAddr}`);
                 done && done();
                 return;
@@ -1157,12 +1157,15 @@ module.exports = function(RED) {
                 node.gateway.removeListener('scene-executed', handleSceneExecuted);
             }
             
+            // 销毁 SyncUtils 实例，清理资源
+            if (node.syncUtils) {
+                node.syncUtils.destroy();
+            }
+            
             // 清空队列和缓存
             node.commandQueue = [];
             node.stateCache = {};
             node.knxStateCache = {};
-            node.lastMeshToKnx = {};
-            node.lastKnxToMesh = {};
             
             node.status({});
             done();

package/nodes/symi-mqtt-brand.html

@@ -20,6 +20,13 @@
         oneditprepare: function() {
             var node = this;
             
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
+            
             // 品牌切换
             function updateBrandUI() {
                 var brand = $('#node-config-input-brand').val();

package/nodes/symi-mqtt-sync.html

@@ -36,8 +36,8 @@
             // 设置编辑面板更宽更高
             var panel = $('#dialog-form').parent();
             if (panel.length) {
-                if (panel.width() < 920) panel.css('width', '900px');
-                if (panel.height() < 700) panel.css('min-height', '700px');
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
             }
 
             var deviceTypes = {