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

package/README.md

@@ -704,6 +704,38 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.10 (2026-01-16)
+
+**新增功能**：
+- **KNX 场景联动支持**：新增“场景”设备类型，支持 Mesh 开关按键与 KNX 场景的双向联动。
+    - **双向同步**：
+        - KNX 触发场景 -> 自动控制 Mesh 开关 (ON/OFF)
+        - Mesh 按键操作 -> 自动触发 KNX 场景 (发送场景号)
+    - **防死循环**：针对场景触发的单向特性，特别优化了防环路机制，确保 Mesh 状态变化后不会再次触发场景发送。
+    - **配置方式**：在 KNX 桥接节点中添加 KNX 实体时选择“场景”类型，需要配置以下三个参数：
+        1. **KNX组地址**：场景控制的组地址（如 1/1/1）。
+        2. **场景号(1-64)**：KNX 标准场景编号（对应 DPT 17.001 0-63 值）。
+         3. **绑定Mesh开关状态**：**必填项**。设置当触发该 KNX 场景时，关联的 Mesh 开关应变为“开”还是“关”。
+            - **为什么必须指定状态？** 场景通常是确定的状态（如“离家”=全关），而不是翻转（Toggle）。如果使用翻转，当灯已经是关闭状态时，再次触发“离家”会导致灯打开，这违背了场景的初衷。
+            - **逻辑说明**：
+                - **KNX -> Mesh**：收到 KNX 场景号 -> Mesh 开关执行指定状态（如设为 0，则执行关）。
+                - **Mesh -> KNX**：Mesh 开关变为指定状态（如变为关） -> 发送 KNX 场景号。
+- **日志优化**：
+    - **错误限流**：当 Mesh 网关离线时，KNX 同步节点会自动抑制重复的连接错误日志（1分钟内只显示一次），避免日志刷屏。
+    - **网络噪音过滤**：TCP 客户端自动过滤常见的网络连接错误（如 EHOSTUNREACH），减少生产环境的日志干扰。
+
+### 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/lib/tcp-client.js

@@ -110,7 +110,8 @@ class TCPClient extends EventEmitter {
                 }
                 // 只在首次连接或重要错误时记录，避免大量重复日志
                 // ECONNRESET通常是网络波动，不记录错误
-                else if (!this.connected && error.code !== 'ECONNREFUSED' && error.code !== 'ECONNRESET') {
+                // EHOSTUNREACH/ETIMEDOUT 也是常见网络错误，不记录
+                else if (!this.connected && !['ECONNREFUSED', 'ECONNRESET', 'EHOSTUNREACH', 'ETIMEDOUT'].includes(error.code)) {
                     this.logger.log('TCP client error: ' + error.message);
                 }
 

package/nodes/symi-knx-bridge.html

@@ -26,7 +26,7 @@
             }
 
             let mappings = [], devices = [], knxEntities = [];
-            const typeLabels = {switch:'开关',light_mono:'单调',light_cct:'双调',light_rgb:'RGB',light_rgbcw:'RGBCW',cover:'窗帘',climate:'空调',fresh_air:'新风',floor_heating:'地暖'};
+            const typeLabels = {switch:'开关',light_mono:'单调',light_cct:'双调',light_rgb:'RGB',light_rgbcw:'RGBCW',cover:'窗帘',climate:'空调',fresh_air:'新风',floor_heating:'地暖',scene:'场景'};
 
             try { mappings = JSON.parse(node.mappings || '[]'); } catch(e) { mappings = []; }
             try { knxEntities = JSON.parse(node.knxEntities || '[]'); } catch(e) { knxEntities = []; }
@@ -64,7 +64,10 @@
 # 新风 (开关, 风速)
 全屋新风	fresh_air	4/1/1	4/2/1
 # 地暖 (开关, 温度, 当前温度)
-客厅地暖	floor_heating	5/1/1	5/2/1	5/3/1`;
+客厅地暖	floor_heating	5/1/1	5/2/1	5/3/1
+# 场景 (地址, 编号, 动作1开0关)
+回家模式	scene	0/0/1	1	1
+离家模式	scene	0/0/1	2	0`;
                 const blob = new Blob([tpl], {type:'text/plain;charset=utf-8'});
                 const a = document.createElement('a'); a.href = URL.createObjectURL(blob);
                 a.download = 'knx-template.txt'; a.click();
@@ -108,7 +111,8 @@
                 'cover': ['上下地址*','位置地址','停止地址'],
                 'climate': ['开关地址*','温度地址','模式地址','风速地址','当前温度'],
                 'fresh_air': ['开关地址*','风速地址'],
-                'floor_heating': ['开关地址*','温度地址','当前温度']
+                'floor_heating': ['开关地址*','温度地址','当前温度'],
+                'scene': ['KNX组地址*', '场景号(1-64)*', '绑定Mesh开关状态(1=开/0=关)*']
             };
             
             // 统一的添加/编辑KNX实体面板
@@ -291,7 +295,7 @@
         .tbl th { background:#f0f0f0; }
         .tbl select { width:100%; font-size:11px; padding:2px; }
         .tbl input[type="checkbox"] { margin:0; }
-        #knx-list, #map-list { max-height:180px; overflow-y:auto; border:1px solid #ccc; margin:5px 0; padding:3px; }
+        #knx-list, #map-list { max-height:450px; overflow-y:auto; border:1px solid #ccc; margin:5px 0; padding:3px; }
         .tips { color:#666; padding:8px; text-align:center; font-size:12px; }
         .sec { display:flex; justify-content:space-between; align-items:center; margin:10px 0 4px; padding-bottom:4px; border-bottom:1px solid #ddd; }
         .sec b { font-size:12px; }

package/nodes/symi-knx-bridge.js

@@ -23,7 +23,8 @@ module.exports = function(RED) {
         'cover': { dpt: '1.008', name: '窗帘', hasChannel: false },
         'climate': { dpt: '9.001', name: '空调', hasChannel: false },
         'fresh_air': { dpt: '1.001', name: '新风', hasChannel: false },
-        'floor_heating': { dpt: '9.001', name: '地暖', hasChannel: false }
+        'floor_heating': { dpt: '9.001', name: '地暖', hasChannel: false },
+        'scene': { dpt: '17.001', name: '场景', hasChannel: false }
     };
 
     function SymiKNXBridgeNode(config) {
@@ -152,7 +153,12 @@ module.exports = function(RED) {
         node.lastSyncTime = 0;
         node.stateCache = {};           // Mesh设备状态缓存
         node.knxStateCache = {};        // KNX设备状态缓存
-        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间，防止自己发的命令又被处理
+        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间
+        node.lastKnxValueSent = {};     // 记录发送到KNX地址的值
+        
+        // 错误日志限流
+        node.lastErrorTime = 0;
+        node.ERROR_THROTTLE_MS = 60000; // 1分钟
         
         // 初始化通用同步工具类
         node.syncUtils = new SyncUtils({
@@ -302,7 +308,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,16 +325,82 @@ 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
                         });
                     }
                 }
+                // 场景设备
+                else if (mapping.deviceType === 'scene') {
+                    const switchKey = `switch_${mapping.meshChannel}`;
+                    if (changed[switchKey] !== undefined) {
+                        const val = changed[switchKey];
+                        const switchValue = (val === 1 || val === true || val === 'on' || val === 'ON');
+                        
+                        // 检查是否匹配配置的触发动作
+                        if (switchValue === mapping.sceneAction) {
+                            // 构造防死循环key
+                            // 注意：这里使用的是 knx-to-mesh 方向的记录来防止 mesh-to-knx 的发送
+                            // 即：如果最近收到了 KNX 场景命令导致 Mesh 变化，这里应该拦截
+                            const sceneLoopKey = `${loopKey}_scene_${mapping.sceneNumber}`;
+                            
+                            if (node.shouldPreventSync('mesh-to-knx', sceneLoopKey)) {
+                                node.log(`[Mesh->KNX] 跳过场景触发(防死循环): ${sceneLoopKey}`);
+                                continue;
+                            }
+                            
+                            // 场景命令 DPT 17.001 (1字节无符号整数)
+                            // payload = 场景号 - 1 (KNX wire format: 0-63)
+                            const scenePayload = mapping.sceneNumber - 1;
+                            
+                            const knxMsg = {
+                                topic: mapping.knxAddrCmd,
+                                payload: scenePayload,
+                                dpt: '17.001',
+                                knx: { 
+                                    destination: mapping.knxAddrCmd, 
+                                    dpt: '17.001', 
+                                    action: 'write' 
+                                }
+                            };
+                            
+                            node.log(`[Mesh->KNX] 场景触发: Mesh开关=${switchValue?'ON':'OFF'} -> 发送场景 ${mapping.sceneNumber} 到 ${mapping.knxAddrCmd}`);
+                            
+                            // 直接发送，不经过通用队列（因为是单向触发）
+                            node.send([knxMsg, {
+                                topic: 'mesh-to-knx',
+                                payload: {
+                                    direction: 'Mesh→KNX',
+                                    type: 'scene',
+                                    scene: mapping.sceneNumber,
+                                    trigger: switchValue ? 'ON' : 'OFF'
+                                },
+                                timestamp: new Date().toISOString()
+                            }]);
+                            
+                            // 记录发送时间
+                            node.lastKnxAddrSent[mapping.knxAddrCmd] = Date.now();
+                            node.lastKnxValueSent[mapping.knxAddrCmd] = scenePayload;
+                            
+                            // 记录同步时间，防止反向循环
+                            node.recordSyncTime('mesh-to-knx', sceneLoopKey);
+                        }
+                    }
+                }
                 // 调光灯设备（单色、双色、RGB、RGBCW）- 简化逻辑：谁动谁跟，忽略过程反馈
                 else if (mapping.deviceType.startsWith('light_')) {
                     if (!eventData.isUserControl) continue;
@@ -551,7 +628,17 @@ module.exports = function(RED) {
                         }
                         await node.sleep(50);  // 命令间隔50ms
                     } catch (err) {
-                        node.log(`同步失败: ${err.message}`);
+                        const now = Date.now();
+                        // 如果是连接相关错误，进行限流
+                        if (err.message && (err.message.includes('Not connected') || err.message.includes('Connection'))) {
+                            if (now - node.lastErrorTime > node.ERROR_THROTTLE_MS) {
+                                node.lastErrorTime = now;
+                                node.error(`同步失败(网关离线): ${err.message} (后续类似错误将被抑制1分钟)`);
+                            }
+                        } else {
+                            // 其他错误正常记录
+                            node.error(`同步失败: ${err.message}`);
+                        }
                     }
                 }
             } finally {
@@ -760,6 +847,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 +1055,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 +1105,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.10",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {