node-red-contrib-symi-modbus 2.2.0 → 2.4.0

package/README.md

@@ -2,69 +2,6 @@
 
 Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成。
 
-> **最新版本 v2.2.0** - 修复Modbus读写并发冲突，实现100%稳定控制
-
-## 版本更新
-
-### v2.2.0 (2025-10-20) - 关键并发问题修复
-
-**核心修复**：
-- 修复Modbus读取（轮询）和写入（控制）之间的并发冲突问题
-- 添加互斥锁机制，确保读写操作不冲突
-- 写入后100ms内暂停该从站轮询，避免读到旧值覆盖新值
-- 改进写入函数为async/await，支持错误捕获和传递
-- 优化MQTT命令处理，异步执行并捕获错误
-- 实现100%稳定控制和状态反馈
-
-**问题描述**（v2.1.0及之前版本）：
-- 轮询每200ms读取32个线圈状态
-- MQTT命令随时写入单个线圈
-- 两者没有互斥保护，会冲突导致写入失败
-- 写入成功后轮询可能立即读到旧值，覆盖刚写入的新值
-- 控制成功率低，尤其是快速连续控制时
-
-**修复后效果**：
-- 轮询检测到写操作时主动跳过，避免冲突
-- 写入操作等待轮询完成后执行，最多等待500ms
-- 写入后100ms内不轮询该从站，确保设备状态已更新
-- 读写操作完全互斥，保证数据一致性
-- 控制成功率100%，状态反馈实时准确
-
-**技术实现**：
-```javascript
-// 添加互斥锁
-node.modbusLock = false;
-node.lastWriteTime = {};
-
-// 轮询时检查锁
-if (node.modbusLock) {
-    return;  // 跳过本次轮询
-}
-
-// 写入时设置锁
-node.modbusLock = true;
-await node.client.writeCoil(coil, value);
-node.lastWriteTime[slaveId] = Date.now();
-node.modbusLock = false;
-```
-
-**测试验证**：
-- 32路线圈连续快速控制，成功率100%
-- 轮询间隔200ms，写入响应<100ms
-- HA控制稳定，状态实时同步
-- 适合Linux工控机24/7长期稳定运行
-
----
-
-**升级方式**：
-```bash
-cd ~/.node-red
-npm install node-red-contrib-symi-modbus@latest
-# 重启Node-RED生效
-```
-
----
-
 ## 功能特性
 
 - 多协议支持：支持Modbus TCP和Modbus RTU（串口）
@@ -569,6 +506,56 @@ docker run --privileged ...
 - **稳定运行**：经过工控机7x24小时长期运行验证，无内存泄漏
 - **容错能力**：Modbus从站离线不影响其他从站，MQTT断线自动重连
 
+
+> **最新版本 v2.4.0** - TCP流式数据帧缓冲、命令队列、LED反馈队列，确保100%稳定控制和反馈
+
+## 版本更新
+
+### v2.4.0 (2025-10-20) - TCP帧缓冲与命令队列机制
+
+**核心修复**：
+- 添加TCP流式数据帧缓冲区，正确处理分包和粘包问题
+- 帧边界检测（7E开始，7D结束），确保完整帧解析
+- 添加MQTT命令队列，防止多个按键同时按下造成冲突
+- 添加LED指示灯反馈队列（40ms间隔），避免RS-485总线过载
+- 增强RS485连接状态提示（明确显示TCP/串口连接成功和监听状态）
+- 分离TCP和串口数据处理逻辑（TCP使用缓冲区，串口直接处理）
+
+**TCP帧缓冲机制**：
+- TCP是流式协议，一个完整的协议帧可能被分成多个数据包
+- 或者多个帧合并在一个数据包中
+- 使用缓冲区累积数据，查找帧头(0x7E)和帧尾(0x7D)
+- 提取完整帧后再解析，确保CRC校验正确
+
+**队列机制**：
+- **命令队列**：多个按键同时按下时，按顺序发送MQTT命令（40ms间隔）
+- **LED反馈队列**：继电器状态反馈到指示灯时，按顺序发送（40ms间隔）
+- 避免MQTT broker和RS-485总线过载
+- 确保每个命令和反馈都被正确处理
+
+**工作流程**：
+```
+物理按键 → TCP数据 → 帧缓冲区 → 提取完整帧 → 解析 → 命令队列 → MQTT发布
+继电器状态变化 → MQTT状态 → LED反馈队列 → RS-485总线 → 指示灯同步
+```
+
+**测试验证**：
+- TCP网关（192.168.2.110:1031）连接正常
+- 帧缓冲区正确处理分包数据
+- 多个按键同时按下不丢失
+- LED指示灯同步稳定
+- 适合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-slave-switch.js

@@ -96,6 +96,17 @@ module.exports = function(RED) {
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
         
+        // TCP帧缓冲区（用于处理分包和粘包）
+        node.frameBuffer = Buffer.alloc(0);
+        
+        // 命令队列（处理多个按键同时按下）
+        node.commandQueue = [];
+        node.isProcessingCommand = false;
+        
+        // 指示灯反馈队列（40ms间隔发送）
+        node.ledFeedbackQueue = [];
+        node.isProcessingLedFeedback = false;
+        
         // MQTT主题（映射到继电器设备）
         node.stateTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/state`;
         node.commandTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/set`;
@@ -185,7 +196,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 +209,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);
@@ -233,116 +246,247 @@ module.exports = function(RED) {
             
             // 监听RS-485数据
             if (node.config.connectionType === "tcp") {
-                // TCP模式：监听socket数据
+                // TCP模式：监听socket数据（需要处理帧边界）
                 if (node.rs485Client._port && node.rs485Client._port.socket) {
                     const socket = node.rs485Client._port.socket;
                     socket.on('data', (data) => {
-                        node.handleRs485Data(data);
+                        node.handleTcpData(data);
                     });
+                    node.log('TCP数据监听已启动（使用帧缓冲区）');
                 }
             } else {
-                // 串口模式：监听串口数据
+                // 串口模式：监听串口数据（串口通常自动处理帧边界）
                 if (node.rs485Client._port) {
                     node.rs485Client._port.on('data', (data) => {
                         node.handleRs485Data(data);
                     });
+                    node.log('串口数据监听已启动');
+                }
+            }
+        };
+        
+        // 处理TCP流式数据（需要缓冲和帧边界检测）
+        node.handleTcpData = function(data) {
+            try {
+                // 将接收到的数据追加到缓冲区
+                node.frameBuffer = Buffer.concat([node.frameBuffer, data]);
+                
+                // 输出缓冲区状态
+                node.log(`TCP收到 ${data.length} 字节，缓冲区共 ${node.frameBuffer.length} 字节`);
+                
+                // 从缓冲区提取完整的帧
+                while (node.frameBuffer.length > 0) {
+                    // 查找帧头 0x7E
+                    const startIdx = node.frameBuffer.indexOf(0x7E);
+                    
+                    if (startIdx === -1) {
+                        // 没有找到帧头，清空缓冲区
+                        node.frameBuffer = Buffer.alloc(0);
+                        break;
+                    }
+                    
+                    if (startIdx > 0) {
+                        // 丢弃帧头之前的无效数据
+                        node.frameBuffer = node.frameBuffer.slice(startIdx);
+                    }
+                    
+                    // 查找帧尾 0x7D
+                    const endIdx = node.frameBuffer.indexOf(0x7D, 1);
+                    
+                    if (endIdx === -1) {
+                        // 没有找到帧尾，等待更多数据
+                        if (node.frameBuffer.length > 100) {
+                            // 缓冲区过大，可能是错误数据，清空
+                            node.warn('缓冲区过大，清空');
+                            node.frameBuffer = Buffer.alloc(0);
+                        }
+                        break;
+                    }
+                    
+                    // 提取完整的帧（包括帧头和帧尾）
+                    const frame = node.frameBuffer.slice(0, endIdx + 1);
+                    
+                    // 从缓冲区移除已处理的帧
+                    node.frameBuffer = node.frameBuffer.slice(endIdx + 1);
+                    
+                    // 处理这一帧
+                    node.handleRs485Data(frame);
                 }
+            } catch (err) {
+                node.error(`TCP数据处理错误: ${err.message}`);
+                node.frameBuffer = Buffer.alloc(0);  // 错误时清空缓冲区
             }
         };
         
         // 处理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(' ')}`);
             }
         };
         
-        // 发送MQTT命令到继电器
+        // 发送MQTT命令到继电器（入队）
         node.sendMqttCommand = function(state) {
             if (!node.mqttClient || !node.mqttClient.connected) {
                 node.warn('MQTT未连接，无法发送命令');
                 return;
             }
             
-            const command = state ? 'ON' : 'OFF';
-            node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
-                if (err) {
-                    node.error(`发布MQTT命令失败: ${err.message}`);
-                } else {
-                    node.log(`按键触发MQTT命令: ${command} → ${node.commandTopic}`);
+            // 加入命令队列
+            node.commandQueue.push(state);
+            node.log(`MQTT命令已入队，队列长度: ${node.commandQueue.length}`);
+            
+            // 启动队列处理
+            node.processCommandQueue();
+        };
+        
+        // 处理命令队列（防止多个按键同时按下造成冲突）
+        node.processCommandQueue = async function() {
+            if (node.isProcessingCommand || node.commandQueue.length === 0) {
+                return;
+            }
+            
+            node.isProcessingCommand = true;
+            
+            while (node.commandQueue.length > 0) {
+                const state = node.commandQueue.shift();
+                const command = state ? 'ON' : 'OFF';
+                
+                try {
+                    await new Promise((resolve, reject) => {
+                        node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
+                            if (err) {
+                                reject(err);
+                            } else {
+                                resolve();
+                            }
+                        });
+                    });
+                    
+                    node.log(`MQTT命令已发送: ${command} → ${node.commandTopic}`);
                     node.currentState = state;
                     node.updateStatus();
+                    
+                    // 队列间隔40ms（避免MQTT broker过载）
+                    if (node.commandQueue.length > 0) {
+                        await new Promise(resolve => setTimeout(resolve, 40));
+                    }
+                } catch (err) {
+                    node.error(`发布MQTT命令失败: ${err.message}`);
                 }
-            });
+            }
+            
+            node.isProcessingCommand = false;
         };
         
-        // 发送控制指令到物理开关面板（控制指示灯等）
-        node.sendCommandToPanel = async function(state) {
+        // 发送控制指令到物理开关面板（控制指示灯等）- 入队
+        node.sendCommandToPanel = function(state) {
             if (!node.isRs485Connected) {
-                node.warn('RS-485未连接');
+                node.warn('RS-485未连接，无法发送指示灯反馈');
                 return;
             }
             
-            try {
-                // 使用轻量级协议构建单灯控制指令
-                // localAddr=0x01（本机），deviceAddr=开关ID，channel=按钮编号，state=开关状态
-                const command = protocol.buildSingleLightCommand(
-                    0x01,  // 本机地址（网关地址）
-                    node.config.switchId,
-                    node.config.buttonNumber,
-                    state
-                );
+            // 加入LED反馈队列
+            node.ledFeedbackQueue.push(state);
+            
+            // 启动队列处理
+            node.processLedFeedbackQueue();
+        };
+        
+        // 处理LED反馈队列（40ms间隔发送）
+        node.processLedFeedbackQueue = async function() {
+            if (node.isProcessingLedFeedback || node.ledFeedbackQueue.length === 0) {
+                return;
+            }
+            
+            node.isProcessingLedFeedback = true;
+            
+            while (node.ledFeedbackQueue.length > 0) {
+                const state = node.ledFeedbackQueue.shift();
                 
-                // 发送到RS-485总线
-                if (node.config.connectionType === "tcp") {
-                    // TCP模式
-                    if (node.rs485Client._port && node.rs485Client._port.socket) {
-                        node.rs485Client._port.socket.write(command);
-                        node.log(`发送控制指令(TCP): 开关${node.config.switchId} 按钮${node.config.buttonNumber} ${state ? 'ON' : 'OFF'}`);
+                try {
+                    // 使用轻量级协议构建单灯控制指令
+                    // localAddr=0x01（本机），deviceAddr=开关ID，channel=按钮编号，state=开关状态
+                    const command = protocol.buildSingleLightCommand(
+                        0x01,  // 本机地址（网关地址）
+                        node.config.switchId,
+                        node.config.buttonNumber,
+                        state
+                    );
+                    
+                    // 发送到RS-485总线
+                    if (node.config.connectionType === "tcp") {
+                        // TCP模式
+                        if (node.rs485Client._port && node.rs485Client._port.socket) {
+                            node.rs485Client._port.socket.write(command);
+                            node.log(`LED反馈已发送(TCP): 开关${node.config.switchId} 按钮${node.config.buttonNumber} ${state ? 'ON' : 'OFF'}`);
+                        }
+                    } else {
+                        // 串口模式
+                        if (node.rs485Client._port) {
+                            node.rs485Client._port.write(command);
+                            node.log(`LED反馈已发送(串口): 开关${node.config.switchId} 按钮${node.config.buttonNumber} ${state ? 'ON' : 'OFF'}`);
+                        }
                     }
-                } else {
-                    // 串口模式
-                    if (node.rs485Client._port) {
-                        node.rs485Client._port.write(command);
-                        node.log(`发送控制指令(串口): 开关${node.config.switchId} 按钮${node.config.buttonNumber} ${state ? 'ON' : 'OFF'}`);
+                    
+                    // 队列间隔40ms
+                    if (node.ledFeedbackQueue.length > 0) {
+                        await new Promise(resolve => setTimeout(resolve, 40));
                     }
+                } catch (err) {
+                    node.error(`发送LED反馈失败: ${err.message}`);
                 }
-            } catch (err) {
-                node.error(`发送控制指令失败: ${err.message}`);
             }
+            
+            node.isProcessingLedFeedback = false;
         };
         
         // 更新节点状态显示

package/package.json

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