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

package/README.md

@@ -507,37 +507,80 @@ docker run --privileged ...
 - **容错能力**：Modbus从站离线不影响其他从站，MQTT断线自动重连
 
 
-> **最新版本 v2.3.0** - Symi轻量级协议完美支持，8键开关面板按键识别正常，MQTT双向同步稳定
+> **最新版本 v2.5.0** - Mac串口兼容性修复，互斥锁优化，确保各平台稳定运行
 
 ## 版本更新
 
-### v2.3.0 (2025-10-20) - Symi轻量级协议支持完善
+### v2.5.0 (2025-10-20) - Mac串口兼容性与互斥锁优化
 
 **核心修复**：
-- 修复从站开关节点对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数据接收时输出原始十六进制数据
-- 协议解析成功输出设备地址、通道、数据类型、操作码
-- 按键匹配成功输出完整的状态信息
-- 按键不匹配时输出期望值和实际值对比
-- 所有日志级别合理，不会造成系统负担
+- 修复Mac串口设备选择问题，明确使用 `/dev/cu.*` 设备
+- 延长互斥锁等待时间（从500ms到6秒），匹配Modbus 5秒超时
+- 优化锁等待间隔（从10ms到50ms），降低CPU占用
+- 添加Mac串口说明到UI（cu.usbserial-xxx, cu.wchusbserial*）
+- 更新串口placeholder提示，包含Mac设备示例
+- 改进超时错误消息，提示可能是轮询阻塞
+
+**Mac串口设备说明**：
+Mac上USB转串口会创建两种设备：
+- `/dev/tty.*` - Terminal设备（用于等待incoming连接）**不要用**
+- `/dev/cu.*` - Call-out设备（用于主动连接）**正确选择**
+
+例如：
+```
+✅ /dev/cu.wchusbserial83420   ← 使用这个
+✅ /dev/cu.usbserial-83420     ← 或这个
+❌ /dev/tty.wchusbserial83420  ← 不要用（会报Resource busy错误）
+❌ /dev/tty.usbserial-83420    ← 不要用
+```
+
+**互斥锁优化说明**：
+- 旧版本：写入操作等待锁最多500ms，但Modbus超时是5000ms
+- 问题：如果轮询超时（5秒），写入操作在500ms就放弃，导致"等待锁释放超时"
+- 修复：写入操作等待锁最多6秒，确保能等到轮询超时后锁释放
+- 等待间隔从10ms增加到50ms，降低CPU占用
+
+**测试验证**：
+- Mac串口连接正常（cu.wchusbserial83420）
+- 轮询和写入操作不再冲突
+- 写入不再提前超时
+- 适合Windows/Linux/macOS平台长期稳定运行
+
+---
+
+### 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总线 → 指示灯同步
+```
 
 **测试验证**：
-- 本地Node-RED环境测试通过
-- 8键开关面板按键识别正常
-- MQTT双向同步稳定
+- TCP网关（192.168.2.110:1031）连接正常
+- 帧缓冲区正确处理分包数据
+- 多个按键同时按下不丢失
+- LED指示灯同步稳定
 - 适合Linux工控机24/7长期稳定运行
 
 ---

package/nodes/modbus-master.html

@@ -311,7 +311,7 @@
         <label for="node-input-serialPort" style="width: 110px;"><i class="fa fa-terminal"></i> 串口</label>
         <div style="display: inline-block; width: calc(70% - 110px);">
             <div style="display: flex; gap: 5px; align-items: center;">
-                <input type="text" id="node-input-serialPort" placeholder="COM1, /dev/ttyUSB0, /dev/ttyS1" style="flex: 1; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
+                <input type="text" id="node-input-serialPort" placeholder="COM1, /dev/ttyUSB0, /dev/cu.usbserial-xxx" style="flex: 1; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
                 <select id="port-list-master" style="flex: 1; padding: 5px; font-family: monospace; font-size: 12px; border: 1px solid #ccc; border-radius: 4px; display: none;">
                     <option value="">-- 选择检测到的串口 --</option>
                 </select>
@@ -324,6 +324,7 @@
                 <span style="color: #555; font-size: 11px;">
                 • <strong>Windows</strong>: COM1, COM2, COM3...<br>
                 • <strong>Linux</strong>: /dev/ttyUSB0, /dev/ttyS0, /dev/ttyAMA0<br>
+                • <strong>macOS</strong>: <span style="background: #fff3cd; padding: 1px 4px; border-radius: 2px; font-weight: 600;">/dev/cu.*</span> (例如 /dev/cu.usbserial-xxx, /dev/cu.wchusbserial*)<br>
                 • <strong>HassOS</strong>: 插件配置添加设备映射即可<br>
                 • <strong>Docker</strong>: 需映射设备 <code style="background: #c8e6c9; padding: 2px 6px; border-radius: 3px; font-size: 10px;">--device=/dev/ttyUSB0</code> 或 <code style="background: #c8e6c9; padding: 2px 6px; border-radius: 3px; font-size: 10px;">--privileged</code>
                 </span>

package/nodes/modbus-master.js

@@ -780,15 +780,15 @@ module.exports = function(RED) {
                 return;
             }
             
-            // 等待锁释放（最多等待500ms）
-            const maxWait = 500;
+            // 等待锁释放（最多等待6秒，因为Modbus超时是5秒）
+            const maxWait = 6000;
             const startWait = Date.now();
             while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 10));
+                await new Promise(resolve => setTimeout(resolve, 50));
             }
             
             if (node.modbusLock) {
-                node.error(`写入线圈超时: 从站${slaveId} 线圈${coil} (等待锁释放超时)`);
+                node.error(`写入线圈超时: 从站${slaveId} 线圈${coil} (等待锁释放超时，轮询可能阻塞)`);
                 return;
             }
             
@@ -834,15 +834,15 @@ module.exports = function(RED) {
                 return;
             }
             
-            // 等待锁释放（最多等待500ms）
-            const maxWait = 500;
+            // 等待锁释放（最多等待6秒，因为Modbus超时是5秒）
+            const maxWait = 6000;
             const startWait = Date.now();
             while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 10));
+                await new Promise(resolve => setTimeout(resolve, 50));
             }
             
             if (node.modbusLock) {
-                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时)`);
+                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时，轮询可能阻塞)`);
                 return;
             }
             

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`;
@@ -235,20 +246,75 @@ 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);  // 错误时清空缓冲区
             }
         };
         
@@ -307,59 +373,120 @@ module.exports = function(RED) {
             }
         };
         
-        // 发送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.3.0",
+  "version": "2.5.0",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、智能MQTT连接（自动fallback HassOS/Docker环境）、Home Assistant自动发现和多品牌开关面板，生产级稳定版本",
   "main": "nodes/modbus-master.js",
   "scripts": {