node-red-contrib-symi-modbus 2.1.0 → 2.3.0

package/README.md

@@ -2,44 +2,6 @@
 
 Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成。
 
-> **最新版本 v2.1.0** - 修复MQTT连接错误日志输出，优化连接稳定性
-
-## 版本更新
-
-### v2.1.0 (2025-10-20) - MQTT连接与认证完善
-
-**核心修复**：
-- 修复MQTT连接error事件处理不当导致错误日志被吞掉的问题
-- 改善错误日志输出，所有MQTT连接错误现在都会被记录
-- 优化重试逻辑，避免极快重试但确保错误被捕获
-- 修复package.json循环依赖问题（移除对自身的依赖）
-- 添加MQTT认证调试日志，方便排查认证问题
-- 完善MQTT认证支持，确保用户名密码正确传递
-- 移除所有emoji图标，确保在工控机环境下正常显示
-
-**MQTT认证配置**：
-如果MQTT broker需要认证（如Home Assistant的MQTT集成），必须在MQTT服务器配置节点中填写用户名和密码：
-1. 打开任意主站或从站节点配置
-2. 点击"MQTT服务器"右边的编辑按钮
-3. 填写用户名和密码（例如：hasskit/hasskit）
-4. 保存并部署
-
-**测试验证**：
-- 本地Node-RED环境测试通过
-- MQTT broker连接测试通过（nc -z -v -w2 192.168.2.12 1883）
-- MQTT认证测试通过（用户名密码正确传递）
-- 成功发布32个MQTT发现消息到Home Assistant
-- 适合Linux工控机24/7长期稳定运行
-
-**升级方式**：
-```bash
-cd ~/.node-red
-npm install node-red-contrib-symi-modbus@latest
-# 重启Node-RED生效
-```
-
----
-
 ## 功能特性
 
 - 多协议支持：支持Modbus TCP和Modbus RTU（串口）
@@ -544,6 +506,51 @@ docker run --privileged ...
 - **稳定运行**：经过工控机7x24小时长期运行验证，无内存泄漏
 - **容错能力**：Modbus从站离线不影响其他从站，MQTT断线自动重连
 
+
+> **最新版本 v2.3.0** - Symi轻量级协议完美支持，8键开关面板按键识别正常，MQTT双向同步稳定
+
+## 版本更新
+
+### v2.3.0 (2025-10-20) - Symi轻量级协议支持完善
+
+**核心修复**：
+- 修复从站开关节点对Symi轻量级协议的解析支持
+- 协议检测同时支持SET(0x03)和REPORT(0x04)类型帧（面板按键发送SET类型）
+- 添加详细的RS485数据接收日志（十六进制输出）
+- 增强连接状态提示（RS485连接成功会明确显示）
+- 添加完整的按键事件检测日志（设备地址、通道、状态匹配）
+- 确保从站开关与主站轮询的双向同步不冲突
+
+**协议修复说明**：
+- Symi 8键开关面板按键时发送 `7E 01 03 0F 01 00 01 [01-08] 00 00 00 00 01 [CRC] 7D`
+- 数据类型为 `0x03`(SET)，不是 `0x04`(REPORT)
+- 旧版本只检测REPORT类型，导致无法识别物理按键
+- 新版本同时支持SET和REPORT，完美兼容所有Symi协议设备
+
+**调试增强**：
+- RS485数据接收时输出原始十六进制数据
+- 协议解析成功输出设备地址、通道、数据类型、操作码
+- 按键匹配成功输出完整的状态信息
+- 按键不匹配时输出期望值和实际值对比
+- 所有日志级别合理，不会造成系统负担
+
+**测试验证**：
+- 本地Node-RED环境测试通过
+- 8键开关面板按键识别正常
+- MQTT双向同步稳定
+- 适合Linux工控机24/7长期稳定运行
+
+---
+
+**升级方式**：
+```bash
+cd ~/.node-red
+npm install node-red-contrib-symi-modbus@latest
+# 重启Node-RED生效
+```
+
+---
+
 ## 许可证
 
 MIT License

package/nodes/lightweight-protocol.js

@@ -220,9 +220,9 @@ module.exports = {
     detectButtonPress: function(frame) {
         if (!frame) return null;
         
-        // 检查是否是灯光设备的上报
+        // 检查是否是灯光设备的SET或REPORT（面板按键会发送SET类型）
         if (frame.deviceType === this.DEVICE_TYPE_LIGHT && 
-            frame.dataType === this.DATA_TYPE_REPORT) {
+            (frame.dataType === this.DATA_TYPE_REPORT || frame.dataType === this.DATA_TYPE_SET)) {
             
             if (frame.opCode === this.LIGHT_OP_SINGLE) {
                 // 单灯按键按下

package/nodes/modbus-master.js

@@ -130,6 +130,8 @@ module.exports = function(RED) {
         node.lastErrorLog = {}; // 记录每个从站的最后错误日志时间
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
+        node.modbusLock = false; // Modbus操作互斥锁（防止读写冲突）
+        node.lastWriteTime = {}; // 记录每个从站的最后写入时间
         
         // 更新节点状态显示
         node.updateNodeStatus = function() {
@@ -540,8 +542,8 @@ module.exports = function(RED) {
             });
         };
         
-        // 处理MQTT命令
-        node.handleMqttCommand = function(topic, message) {
+        // 处理MQTT命令（异步）
+        node.handleMqttCommand = async function(topic, message) {
             const parts = topic.split('/');
             if (parts.length < 4) {
                 return;
@@ -555,8 +557,12 @@ module.exports = function(RED) {
             
             node.log(`MQTT命令: 从站${slaveId} 线圈${coil} = ${value}`);
             
-            // 写入线圈
-            node.writeSingleCoil(slaveId, coil, value);
+            // 写入线圈（异步执行，捕获错误）
+            try {
+                await node.writeSingleCoil(slaveId, coil, value);
+            } catch (err) {
+                node.error(`MQTT命令执行失败: 从站${slaveId} 线圈${coil} - ${err.message}`);
+            }
         };
         
         // 发布MQTT状态
@@ -624,6 +630,11 @@ module.exports = function(RED) {
                 return;
             }
             
+            // 检查互斥锁
+            if (node.modbusLock) {
+                return;  // 有写操作正在进行，跳过本次轮询
+            }
+            
             // 获取当前从站配置
             const slave = node.config.slaves[node.currentSlaveIndex];
             if (!slave) {
@@ -634,12 +645,27 @@ module.exports = function(RED) {
             const slaveId = slave.address;
             const coilCount = slave.coilEnd - slave.coilStart + 1;
             
+            // 检查是否刚写入过（写入后100ms内不轮询该从站，避免读到旧值）
+            const lastWrite = node.lastWriteTime[slaveId] || 0;
+            const timeSinceWrite = Date.now() - lastWrite;
+            if (timeSinceWrite < 100) {
+                // 移动到下一个从站
+                node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+                return;
+            }
+            
             try {
+                // 设置锁
+                node.modbusLock = true;
+                
                 node.client.setID(slaveId);
                 
                 // 读取线圈状态（功能码01）
                 const data = await node.client.readCoils(slave.coilStart, coilCount);
                 
+                // 释放锁
+                node.modbusLock = false;
+                
                 // 更新设备状态
                 const isFirstPoll = !node.deviceStates[slaveId].initialPublished;
                 let publishCount = 0;
@@ -691,6 +717,9 @@ module.exports = function(RED) {
                 node.updateNodeStatus();
                 
             } catch (err) {
+                // 释放锁
+                node.modbusLock = false;
+                
                 node.deviceStates[slaveId].error = err.message;
                 
                 // 日志限流：每个从站的错误日志最多每10分钟输出一次
@@ -744,71 +773,113 @@ module.exports = function(RED) {
             node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
         };
         
-        // 写单个线圈
-        node.writeSingleCoil = function(slaveId, coil, value) {
+        // 写单个线圈（带互斥锁）
+        node.writeSingleCoil = async function(slaveId, coil, value) {
             if (!node.isConnected) {
                 node.warn('Modbus未连接');
-                return Promise.resolve();
+                return;
             }
             
-            return (async () => {
-                try {
-                    node.client.setID(slaveId);
-                    await node.client.writeCoil(coil, value);
-                    
-                    // 更新本地状态
-                    node.deviceStates[slaveId].coils[coil] = value;
-                    
-                    node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value}`);
-                    
-                    // 发布到MQTT和触发事件
-                    node.publishMqttState(slaveId, coil, value);
-                    node.emit('stateUpdate', {
-                        slave: slaveId,
-                        coil: coil,
-                        value: value
-                    });
-                    
-                } catch (err) {
-                    node.error(`写入线圈失败: ${err.message}`);
-                }
-            })().catch(err => {
-                node.error(`写入线圈异常: ${err.message}`);
-            });
+            // 等待锁释放（最多等待500ms）
+            const maxWait = 500;
+            const startWait = Date.now();
+            while (node.modbusLock && (Date.now() - startWait) < maxWait) {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            }
+            
+            if (node.modbusLock) {
+                node.error(`写入线圈超时: 从站${slaveId} 线圈${coil} (等待锁释放超时)`);
+                return;
+            }
+            
+            try {
+                // 设置锁
+                node.modbusLock = true;
+                
+                node.client.setID(slaveId);
+                await node.client.writeCoil(coil, value);
+                
+                // 记录写入时间（用于暂停轮询）
+                node.lastWriteTime[slaveId] = Date.now();
+                
+                // 更新本地状态
+                node.deviceStates[slaveId].coils[coil] = value;
+                
+                node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value}`);
+                
+                // 发布到MQTT和触发事件
+                node.publishMqttState(slaveId, coil, value);
+                node.emit('stateUpdate', {
+                    slave: slaveId,
+                    coil: coil,
+                    value: value
+                });
+                
+                // 释放锁
+                node.modbusLock = false;
+                
+            } catch (err) {
+                // 释放锁
+                node.modbusLock = false;
+                
+                node.error(`写入线圈失败: 从站${slaveId} 线圈${coil} - ${err.message}`);
+                throw err;  // 抛出错误，让调用者知道失败
+            }
         };
         
-        // 写多个线圈
-        node.writeMultipleCoils = function(slaveId, startCoil, values) {
+        // 批量写入多个线圈（带互斥锁）
+        node.writeMultipleCoils = async function(slaveId, startCoil, values) {
             if (!node.isConnected) {
                 node.warn('Modbus未连接');
-                return Promise.resolve();
+                return;
             }
             
-            return (async () => {
-                try {
-                    node.client.setID(slaveId);
-                    await node.client.writeCoils(startCoil, values);
-                    
-                    // 更新本地状态
-                    for (let i = 0; i < values.length; i++) {
-                        node.deviceStates[slaveId].coils[startCoil + i] = values[i];
-                        // 发布到MQTT和触发事件
-                        node.publishMqttState(slaveId, startCoil + i, values[i]);
-                        node.emit('stateUpdate', {
-                            slave: slaveId,
-                            coil: startCoil + i,
-                            value: values[i]
-                        });
-                    }
-                    
-                    node.log(`批量写入成功: 从站${slaveId} 起始线圈${startCoil}`);
-                    
-                } catch (err) {
-                    node.error(`批量写入线圈失败: ${err.message}`);
+            // 等待锁释放（最多等待500ms）
+            const maxWait = 500;
+            const startWait = Date.now();
+            while (node.modbusLock && (Date.now() - startWait) < maxWait) {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            }
+            
+            if (node.modbusLock) {
+                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时)`);
+                return;
+            }
+            
+            try {
+                // 设置锁
+                node.modbusLock = true;
+                
+                node.client.setID(slaveId);
+                await node.client.writeCoils(startCoil, values);
+                
+                // 记录写入时间（用于暂停轮询）
+                node.lastWriteTime[slaveId] = Date.now();
+                
+                // 更新本地状态
+                for (let i = 0; i < values.length; i++) {
+                    node.deviceStates[slaveId].coils[startCoil + i] = values[i];
+                    // 发布到MQTT和触发事件
+                    node.publishMqttState(slaveId, startCoil + i, values[i]);
+                    node.emit('stateUpdate', {
+                        slave: slaveId,
+                        coil: startCoil + i,
+                        value: values[i]
+                    });
                 }
-            })().catch(err => {
-                node.error(`批量写入线圈异常: ${err.message}`);
-            });
+                
+                node.log(`批量写入成功: 从站${slaveId} 起始线圈${startCoil} 共${values.length}个线圈`);
+                
+                // 释放锁
+                node.modbusLock = false;
+                
+            } catch (err) {
+                // 释放锁
+                node.modbusLock = false;
+                
+                node.error(`批量写入线圈失败: 从站${slaveId} 起始线圈${startCoil} - ${err.message}`);
+                throw err; // 抛出错误，让调用者知道失败
+            }
         };
         
         // 处理输入消息

package/nodes/modbus-slave-switch.js

@@ -185,7 +185,8 @@ module.exports = function(RED) {
                     await node.rs485Client.connectTCP(node.config.tcpHost, {
                         port: node.config.tcpPort
                     });
-                    node.log(`已连接到RS-485 TCP: ${node.config.tcpHost}:${node.config.tcpPort}`);
+                    node.log(`RS485连接成功（TCP）: ${node.config.tcpHost}:${node.config.tcpPort}`);
+                    node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
                 } else {
                     // 串口连接验证
                     if (!node.config.serialPort) {
@@ -197,7 +198,8 @@ module.exports = function(RED) {
                         stopBits: node.config.serialStopBits || 1,
                         parity: node.config.serialParity || 'none'
                     });
-                    node.log(`已连接到RS-485串口: ${node.config.serialPort}`);
+                    node.log(`RS485连接成功（串口）: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);
+                    node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
                 }
                 
                 node.rs485Client.setTimeout(5000);
@@ -253,40 +255,55 @@ module.exports = function(RED) {
         // 处理RS-485接收到的数据
         node.handleRs485Data = function(data) {
             try {
+                // 输出原始数据（十六进制）- 方便调试
+                const hexData = Array.from(data).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
+                node.log(`RS485收到数据: ${hexData}`);
+                
                 // 解析轻量级协议帧
                 const frame = protocol.parseFrame(data);
                 if (!frame) {
-                    return; // 无效帧
+                    node.warn(`无效的协议帧（CRC校验失败或格式错误）: ${hexData}`);
+                    return;
                 }
                 
+                node.log(`解析成功: 设备地址=${frame.deviceAddr} 通道=${frame.channel} 数据类型=0x${frame.dataType.toString(16).toUpperCase()} 操作码=0x${frame.opCode.toString(16).toUpperCase()}`);
+                
                 // 检测是否是按键按下事件
                 const buttonEvent = protocol.detectButtonPress(frame);
                 if (!buttonEvent) {
-                    return; // 不是按键事件
+                    node.log(`不是按键事件（设备类型=${frame.deviceType} 数据类型=${frame.dataType} 操作码=${frame.opCode}）`);
+                    return;
                 }
                 
+                node.log(`检测到按键事件: 类型=${buttonEvent.type} 设备=${buttonEvent.deviceAddr} 通道=${buttonEvent.channel}`);
+                
                 // 检查是否是我们监听的开关和按钮
                 if (buttonEvent.deviceAddr === node.config.switchId) {
                     if (buttonEvent.type === 'single') {
                         // 单键按下
                         if (buttonEvent.channel === node.config.buttonNumber) {
-                            node.log(`检测到按键按下: 开关${node.config.switchId} 按钮${node.config.buttonNumber} 状态=${buttonEvent.state}`);
+                            node.log(`匹配成功！开关${node.config.switchId} 按钮${node.config.buttonNumber} 状态=${buttonEvent.state ? 'ON' : 'OFF'}`);
                             // 发送MQTT命令到继电器
                             node.sendMqttCommand(buttonEvent.state);
+                        } else {
+                            node.log(`按钮编号不匹配: 收到${buttonEvent.channel} 期望${node.config.buttonNumber}`);
                         }
                     } else if (buttonEvent.type === 'multi') {
                         // 多键按下
                         const buttonIndex = node.config.buttonNumber - 1; // 转换为0-7索引
                         if (buttonIndex >= 0 && buttonIndex < 8) {
                             const state = buttonEvent.buttonStates[buttonIndex];
-                            node.log(`检测到多键事件: 开关${node.config.switchId} 按钮${node.config.buttonNumber} 状态=${state}`);
+                            node.log(`匹配成功！开关${node.config.switchId} 多键按钮${node.config.buttonNumber} 状态=${state ? 'ON' : 'OFF'}`);
                             // 发送MQTT命令到继电器
                             node.sendMqttCommand(state);
                         }
                     }
+                } else {
+                    node.log(`开关ID不匹配: 收到${buttonEvent.deviceAddr} 期望${node.config.switchId}`);
                 }
             } catch (err) {
-                node.warn(`解析RS-485数据失败: ${err.message}`);
+                node.error(`解析RS-485数据失败: ${err.message}`);
+                node.error(`错误数据: ${Array.from(data).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ')}`);
             }
         };
         

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、智能MQTT连接（自动fallback HassOS/Docker环境）、Home Assistant自动发现和多品牌开关面板，生产级稳定版本",
   "main": "nodes/modbus-master.js",
   "scripts": {