node-red-contrib-symi-mesh 1.8.8 → 1.8.9

package/README.md

@@ -704,6 +704,18 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.9 (2026-01-14)
+
+**KNX 协议回显消除算法升级**：
+- **值校验机制**：在原有的“时间窗口”回显消除基础上，新增“状态值”深度比对。
+    - **原理**：当 KNX 收到消息时，不仅检查该设备最近是否发送过命令，还对比收到的值与发出的值是否一致。
+    - **效果**：彻底解决“Mesh 开 -> KNX 开 -> 立即 KNX 关”场景下，OFF 指令被误判为回显而被拦截的问题。只有当时间相近且值完全相同时，才判定为回显并忽略；值发生变化时，立即响应并同步，实现毫秒级双向跟随。
+**KNX 开关双向同步逻辑深度优化**：
+- **防死循环机制精细化**：将开关设备的防死循环锁从“设备+通道”级别细化到“设备+通道+状态值”级别。
+    - **修复场景**：KNX 控制打开（ON）后，立即手动关闭 Mesh 设备（OFF），旧版本会因死循环锁未过期而丢弃 OFF 状态上报。
+    - **新逻辑**：KNX 发送 ON 指令只锁定 Mesh->KNX 的 ON 上报，不影响 Mesh->KNX 的 OFF 上报，确保快速连续反向操作能 100% 同步。
+- **状态同步零延迟**：移除不必要的通用防抖检查，确保 Mesh 端的状态变化能毫秒级同步到 KNX 总线。
+
 ### v1.8.8 (2026-01-14)
 
 **KNX 双向同步深度修复与协议鲁棒性增强**：

package/nodes/symi-knx-bridge.js

@@ -152,7 +152,8 @@ module.exports = function(RED) {
         node.lastSyncTime = 0;
         node.stateCache = {};           // Mesh设备状态缓存
         node.knxStateCache = {};        // KNX设备状态缓存
-        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间，防止自己发的命令又被处理
+        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间
+        node.lastKnxValueSent = {};     // 记录发送到KNX地址的值
         
         // 初始化通用同步工具类
         node.syncUtils = new SyncUtils({
@@ -302,7 +303,12 @@ module.exports = function(RED) {
                 // 窗帘设备需要单独处理防死循环（动作和位置分开检查）
                 if (mapping.deviceType === 'cover') {
                     // 窗帘的防死循环在内部单独处理，这里不跳过
-                } else {
+                } 
+                // 开关设备使用带值的精细化key，这里先不检查
+                else if (mapping.deviceType === 'switch') {
+                    // 在具体处理逻辑中检查
+                }
+                else {
                     // 其他设备统一防死循环检查
                     if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
                         node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
@@ -314,13 +320,22 @@ module.exports = function(RED) {
                 if (mapping.deviceType === 'switch') {
                     const switchKey = `switch_${mapping.meshChannel}`;
                     if (changed[switchKey] !== undefined) {
-                        node.log(`[Mesh->KNX] 开关变化: ${mapping.name || eventData.device.name} CH${mapping.meshChannel} = ${changed[switchKey]}`);
+                        const val = changed[switchKey];
+                        const switchValue = (val === 1 || val === true || val === 'on' || val === 'ON');
+                        const specificLoopKey = `${loopKey}_switch_${switchValue}`;
+                        
+                        if (node.shouldPreventSync('mesh-to-knx', specificLoopKey)) {
+                            node.log(`[Mesh->KNX] 跳过(防死循环): ${specificLoopKey}`);
+                            continue;
+                        }
+
+                        node.log(`[Mesh->KNX] 开关变化: ${mapping.name || eventData.device.name} CH${mapping.meshChannel} = ${val}`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
                             mapping: mapping,
                             type: 'switch',
-                            value: changed[switchKey],
-                            key: loopKey
+                            value: val,
+                            key: specificLoopKey
                         });
                     }
                 }
@@ -760,6 +775,7 @@ module.exports = function(RED) {
                 // 记录发送到的KNX地址和时间，防止自己发的命令又被处理
                 const destAddr = knxMsg.knx.destination;
                 node.lastKnxAddrSent[destAddr] = Date.now();
+                node.lastKnxValueSent[destAddr] = knxMsg.payload;
                 
                 // knxUltimate输入格式：topic + destination + payload + dpt + event
                 // topic: 当setTopicType=str时，knxUltimate使用msg.topic作为目标地址
@@ -967,36 +983,42 @@ module.exports = function(RED) {
             }
 
             // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
-            // 检查该设备的所有关联地址，只要有一个最近发送过，就认为是回显
-            const wasSentRecently = mapping.allKnxAddrs.some(addr => {
+            // 检查该设备的所有关联地址，只要有一个最近发送过且值相同，就认为是回显
+            const isEcho = mapping.allKnxAddrs.some(addr => {
                 const lastSentTime = node.lastKnxAddrSent[addr] || 0;
-                return (Date.now() - lastSentTime) < DEFAULT_TIMEOUT;
+                const inWindow = (Date.now() - lastSentTime) < DEFAULT_TIMEOUT;
+                if (!inWindow) return false;
+                
+                // 如果在时间窗口内，进一步检查值是否相同
+                const lastValue = node.lastKnxValueSent[addr];
+                // 对于布尔值，直接比较；对于数字，允许微小误差？KNX通常是精确的
+                return msg.payload === lastValue;
             });
 
-            if (wasSentRecently) {
-                node.debug(`[KNX输入] 跳过(自己发的回显): ${groupAddr} (设备: ${mapping.name})`);
+            if (isEcho) {
+                node.debug(`[KNX输入] 跳过(自己发的回显): ${groupAddr} (设备: ${mapping.name}, 值: ${msg.payload})`);
                 done && done();
                 return;
             }
             
             // 确定地址功能（优先使用地址匹配，比DPT更可靠）
             const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
-            const loopKey = `${mapping.meshMac}_${mapping.meshChannel}`;
-            
-            // 防死循环检查（基于设备的双向同步防护）
-            if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
-                node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
-                done && done();
-                return;
-            }
-            
-            node.log(`[KNX输入] 收到: ${groupAddr} = ${value}, DPT=${dpt}, 功能=${addrFunc}, 设备=${mapping.deviceType}`);
             
             // 根据设备类型和地址功能处理
             if (mapping.deviceType === 'switch') {
                 // 开关命令（只处理cmd地址）
                 if (addrFunc === 'cmd' || addrFunc === 'status') {
                     const switchValue = (value === 1 || value === true || value === 'on' || value === 'ON');
+                    const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_switch_${switchValue}`;
+                    
+                    // 防死循环检查
+                    if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
+                        node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
+                        done && done();
+                        return;
+                    }
+
+                    node.log(`[KNX输入] 收到: ${groupAddr} = ${value}, DPT=${dpt}, 功能=${addrFunc}, 设备=${mapping.deviceType}`);
                     node.queueCommand({
                         direction: 'knx-to-mesh',
                         mapping: mapping,
@@ -1011,6 +1033,7 @@ module.exports = function(RED) {
             else if (mapping.deviceType === 'cover') {
                 const deviceKey = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
                 const now = Date.now();
+                const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_cover`; // 窗帘使用通用key，因为有专门的controlLock
                 
                 // KNX主动发起控制，直接抢占锁定（用户操作优先）
                 node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };

package/package.json

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