node-red-contrib-symi-mesh 1.6.7 → 1.6.8

package/README.md

@@ -1036,6 +1036,18 @@ node-red-contrib-symi-mesh/
   - 多设备类型：开关、调光灯、窗帘、空调、新风、地暖
   - 智能通道选择：根据Mesh设备实际路数显示可选通道
 
+### v1.6.8 (2025-12-15)
+- **KNX双向同步修复**：彻底修复米家/面板操作KNX不同步的问题
+  - 修复0x45消息类型处理：米家/面板操作发送msgType=0x45，不再限制channels>=6
+  - 支持1-4路开关2字节参数解析（米家/面板场景触发格式）
+  - 场景执行通知(0x11)后自动查询设备状态
+- **syncLock阻塞修复**：移除handleMeshStateChange中syncLock检查
+  - 避免队列处理期间丢失状态变化事件
+  - 改用per-device时间戳防回环机制
+- **processQueue健壮性**：添加try/finally确保processing标志正确重置
+- **防死循环参数调整**：LOOP_PREVENTION_MS调整为800ms
+- **同时修复RS485桥接**：应用相同syncLock修复
+
 ### v1.6.6 (2025-12-09)
 - **三合一面板完整双向同步**：支持空调+新风+地暖独立RS485映射
   - 三合一0x94协议完整解析：空调(开关/模式/风速/温度)、地暖(开关/温度)、新风(开关/风速)
@@ -1092,8 +1104,8 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.6.7
+**版本**: 1.6.8
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
-**最后更新**: 2025-12-10
+**最后更新**: 2025-12-15
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh
 **npm包**: https://www.npmjs.com/package/node-red-contrib-symi-mesh

package/lib/device-manager.js

@@ -85,7 +85,9 @@ class DeviceInfo {
             case 0x45:
                 // 6-8路开关状态上报（2字节，小端序）
                 // 用于场景执行后的状态同步
-                if (this.channels >= 6) {
+                // 注意：米家/面板操作会发送0x45类型，不管实际路数
+                // 窗帘(type=5)不使用0x45
+                if (this.deviceType !== 5) {
                     this.handleSwitchState(parameters);
                 }
                 break;
@@ -385,8 +387,14 @@ class DeviceInfo {
             const value = parameters[0];
             this.state.switch = value === 0x02;
         } else if (this.channels <= 4) {
-            // 1-4路开关：1字节，每2位表示1路
-            const value = parameters[0];
+            // 1-4路开关：通常1字节，但米家/面板操作可能发送2字节(0x45类型)
+            let value;
+            if (parameters.length >= 2) {
+                // 2字节：小端序（米家/面板场景触发）
+                value = parameters[0] | (parameters[1] << 8);
+            } else {
+                value = parameters[0];
+            }
             // 保存原始状态值供控制时使用
             this.state.switchState = value;
             for (let i = 0; i < this.channels; i++) {

package/nodes/symi-485-bridge.js

@@ -530,7 +530,7 @@ module.exports = function(RED) {
 
         // Mesh设备状态变化处理(事件驱动)
         const handleMeshStateChange = (eventData) => {
-            if (node.syncLock) return;
+            // 只检查initializing，不检查syncLock以避免丢失事件
             if (node.initializing) return;
             
             const mac = eventData.device.macAddress;
@@ -972,7 +972,7 @@ module.exports = function(RED) {
 
         // RS485 device state change handler (event-driven)
         const handleModbusStateChange = (data) => {
-            if (node.syncLock) return;
+            // 不检查syncLock以避免丢失事件，使用时间戳防回环
             
             const mapping = node.findRS485Mapping(data.device.modbusAddress);
             if (!mapping) return;
@@ -1025,36 +1025,36 @@ module.exports = function(RED) {
             if (node.processing || node.commandQueue.length === 0) return;
 
             node.processing = true;
-            node.syncLock = true;
             let multiChange = node.commandQueue.length > 1;
 
-            while (node.commandQueue.length > 0) {
-                const cmd = node.commandQueue.shift();
-                try {
-                    if (cmd.direction === 'mesh-to-modbus') {
-                        await node.syncMeshToModbus(cmd);
-                    } else if (cmd.direction === 'modbus-to-mesh') {
-                        await node.syncModbusToMesh(cmd);
+            try {
+                while (node.commandQueue.length > 0) {
+                    const cmd = node.commandQueue.shift();
+                    try {
+                        if (cmd.direction === 'mesh-to-modbus') {
+                            await node.syncMeshToModbus(cmd);
+                        } else if (cmd.direction === 'modbus-to-mesh') {
+                            await node.syncModbusToMesh(cmd);
+                        }
+                        // 命令之间延迟50ms
+                        await node.sleep(50);
+                    } catch (err) {
+                        node.error(`同步失败: ${err.message}`);
                     }
-                    // 命令之间延迟50ms
-                    await node.sleep(50);
-                } catch (err) {
-                    node.error(`同步失败: ${err.message}`);
                 }
-            }
 
-            // 如果发生多次变化，安排验证
-            if (multiChange && !node.pendingVerify) {
-                node.pendingVerify = true;
-                setTimeout(() => {
-                    node.verifySync();
-                    node.pendingVerify = false;
-                }, 200);
+                // 如果发生多次变化，安排验证
+                if (multiChange && !node.pendingVerify) {
+                    node.pendingVerify = true;
+                    setTimeout(() => {
+                        node.verifySync();
+                        node.pendingVerify = false;
+                    }, 200);
+                }
+            } finally {
+                node.processing = false;
+                node.lastSyncTime = Date.now();
             }
-
-            node.syncLock = false;
-            node.processing = false;
-            node.lastSyncTime = Date.now();
         };
 
         // 多实体变化后验证同步状态
@@ -2098,7 +2098,6 @@ module.exports = function(RED) {
             node.curtainCache = {};
             node.lastSentTime = {};
             node.processing = false;
-            node.syncLock = false;
             
             node.log('[RS485 Bridge] 节点已清理');
             done();

package/nodes/symi-gateway.js

@@ -217,6 +217,13 @@ module.exports = function(RED) {
                         Buffer.from([frame.checksum])
                     ]).toString('hex').toUpperCase();
                     this.log(`[场景执行] 收到场景执行通知事件: 场景ID=${sceneId}, 设备地址=0x${event.networkAddress.toString(16).toUpperCase()}, 原始帧=${frameHex}`);
+                    
+                    // 发出场景执行事件，让桥接节点知道需要查询设备状态
+                    this.emit('scene-executed', {
+                        sceneId: sceneId,
+                        triggerAddress: event.networkAddress,
+                        timestamp: Date.now()
+                    });
                     continue;
                 }
 

package/nodes/symi-knx-bridge.js

@@ -3,7 +3,7 @@
  * 支持开关、窗帘等设备的双向状态同步
  * 事件驱动架构，命令队列顺序处理，防死循环机制
  * 
- * 版本: 1.6.7
+ * 版本: 1.6.8
  */
 
 module.exports = function(RED) {
@@ -151,7 +151,7 @@ module.exports = function(RED) {
         node.lastKnxToMesh = {};        // 记录KNX->Mesh发送时间，防止回环
         
         // 防死循环参数
-        const LOOP_PREVENTION_MS = 1000;  // 500ms内不处理反向同步
+        const LOOP_PREVENTION_MS = 800;   // 800ms内不处理反向同步，防止回环
         const DEBOUNCE_MS = 100;          // 100ms防抖
         const MAX_QUEUE_SIZE = 100;       // 最大队列大小
         
@@ -249,7 +249,9 @@ module.exports = function(RED) {
 
         // ========== Mesh设备状态变化处理 ==========
         const handleMeshStateChange = (eventData) => {
-            if (node.syncLock || node.initializing) return;
+            // 只检查initializing，不检查syncLock
+            // syncLock会导致队列处理期间丢失事件，改用per-device时间戳防回环
+            if (node.initializing) return;
             
             const mac = eventData.device.macAddress;
             const state = eventData.state || {};
@@ -489,25 +491,25 @@ module.exports = function(RED) {
             if (node.processing || node.commandQueue.length === 0) return;
             
             node.processing = true;
-            node.syncLock = true;
             
-            while (node.commandQueue.length > 0) {
-                const cmd = node.commandQueue.shift();
-                try {
-                    if (cmd.direction === 'mesh-to-knx') {
-                        await node.syncMeshToKnx(cmd);
-                    } else if (cmd.direction === 'knx-to-mesh') {
-                        await node.syncKnxToMesh(cmd);
+            try {
+                while (node.commandQueue.length > 0) {
+                    const cmd = node.commandQueue.shift();
+                    try {
+                        if (cmd.direction === 'mesh-to-knx') {
+                            await node.syncMeshToKnx(cmd);
+                        } else if (cmd.direction === 'knx-to-mesh') {
+                            await node.syncKnxToMesh(cmd);
+                        }
+                        await node.sleep(50);  // 命令间隔50ms
+                    } catch (err) {
+                        node.error(`同步失败: ${err.message}`);
                     }
-                    await node.sleep(50);  // 命令间隔50ms
-                } catch (err) {
-                    node.error(`同步失败: ${err.message}`);
                 }
+            } finally {
+                node.processing = false;
+                node.lastSyncTime = Date.now();
             }
-            
-            node.syncLock = false;
-            node.processing = false;
-            node.lastSyncTime = Date.now();
         };
 
         // ========== Mesh -> KNX 同步 ==========
@@ -1018,6 +1020,48 @@ module.exports = function(RED) {
         // 监听Mesh设备状态变化
         node.gateway.on('device-state-changed', handleMeshStateChange);
         
+        // ========== 场景执行事件处理 ==========
+        // 当收到场景执行通知时，查询所有已映射设备的状态
+        const handleSceneExecuted = (eventData) => {
+            if (node.initializing) return;
+            
+            node.log(`[场景执行] 检测到场景${eventData.sceneId}执行，延迟查询设备状态`);
+            
+            // 延迟300ms后查询设备状态，给设备执行时间
+            setTimeout(async () => {
+                // 收集所有已映射的唯一设备地址
+                const mappedAddresses = new Set();
+                for (const mapping of node.mappings) {
+                    const mac = node.normalizeMac(mapping.meshMac);
+                    const device = node.gateway.deviceManager.getDeviceByMac(mac);
+                    if (device && device.networkAddress) {
+                        mappedAddresses.add(device.networkAddress);
+                    }
+                }
+                
+                if (mappedAddresses.size === 0) {
+                    node.debug(`[场景执行] 没有已映射的设备需要查询`);
+                    return;
+                }
+                
+                node.log(`[场景执行] 查询${mappedAddresses.size}个设备的状态`);
+                
+                // 逐个查询设备状态
+                for (const addr of mappedAddresses) {
+                    try {
+                        // 查询开关状态 (0x02)
+                        const queryFrame = node.gateway.protocolHandler.buildDeviceStatusQueryFrame(addr, 0x02);
+                        await node.gateway.client.sendFrame(queryFrame, 2);
+                        await node.sleep(100);
+                    } catch (err) {
+                        node.debug(`[场景执行] 查询设备0x${addr.toString(16)}状态失败: ${err.message}`);
+                    }
+                }
+            }, 300);
+        };
+        
+        node.gateway.on('scene-executed', handleSceneExecuted);
+        
         // ========== 清理 ==========
         node.on('close', function(done) {
             // 清除初始化定时器
@@ -1028,6 +1072,7 @@ module.exports = function(RED) {
             // 移除事件监听
             if (node.gateway) {
                 node.gateway.removeListener('device-state-changed', handleMeshStateChange);
+                node.gateway.removeListener('scene-executed', handleSceneExecuted);
             }
             
             // 清空队列和缓存

package/package.json

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