node-red-contrib-symi-modbus 2.7.8 → 2.8.0

package/README.md

@@ -267,7 +267,7 @@ node-red-restart
    - 长期稳定运行，反复控制不会造成内存增加、卡顿或死机
 
 4. **技术细节**：
-   - 写入队列间隔：20ms（确保总线稳定）
+   - 写入队列间隔：30ms（确保总线稳定）
    - 轮询恢复时间：20ms（快速响应）
    - 锁等待超时：100ms（快速检测异常）
    - 队列自动处理，无需手动干预
@@ -883,38 +883,44 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.7.8
-
-### v2.7.8 (2025-11-08)
-
-**重要修复**：
-- 修复LED反馈队列优先级问题：状态变化时清空旧队列，确保面板显示最新状态
-- 优化队列去重逻辑：避免ON→OFF→ON时第二个ON被跳过的问题
-- 确保双控场景下所有开关面板都能收到最新状态反馈
-- 修复160个继电器同时变化时的队列处理完整性
-
-**队列处理机制**：
-- 智能优先级：新状态变化时自动清空旧队列，优先发送最新状态
-- 完整性保证：确保所有LED反馈都能正确发送到物理开关面板
-- 双控支持：多个开关按钮控制同一个继电器时，所有面板都能正确同步
-- 性能优化：20ms间隔处理，160个继电器反馈耗时约3.2秒
-
-### v2.7.7 (2025-11-08)
-
-**重要修复**：
-- 修复从站开关节点"无效节点"警告问题（serialPortConfig改为非必需字段）
-- 兼容旧版本节点配置，避免升级后出现红色三角形警告
-- 优化节点验证逻辑，提供更友好的错误提示
-
-**功能改进**：
-- Mesh设备扫描成功率100%（之前超时失败）
-- 与symi-gateway节点完美共存（不再冲突）
-- TCP和串口使用统一的共享连接机制
-- 设备列表持久化保存，重启无需重新扫描
-- 详细的扫描日志，便于问题排查
-- 看板节点和HomeKit节点点击刷新按钮即可显示新增从站（无需重新部署）
-- 看板节点窗口高度增加到700px，HomeKit节点窗口高度增加到600px，一次展示更多继电器
-- 完善内存清理机制，防止定时器泄漏，确保长期稳定运行
+**当前版本**: v2.8.0
+
+### v2.8.0 (2025-11-10)
+
+**重要更新**：
+- 优化指示灯反馈稳定性，统一队列间隔为30ms（TCP和串口）
+- 修复高频控制场景下指示灯反馈丢失问题
+- 提升批量控制时的总线稳定性
+
+**队列处理机制**（全局统一队列）：
+- **全局队列**：所有从站开关节点共享同一个全局队列（由serial-port-config管理）
+- **串行发送**：所有LED反馈按加入队列的顺序依次发送，间隔30ms（TCP和串口统一）
+- **完整性保证**：所有LED反馈都能正确发送，不会遗漏
+- **去重机制**：每个节点50ms内不重复发送相同状态，避免总线拥堵
+- **性能优化**：400个按键（50个8键开关）反馈耗时约12秒（30ms×400）
+
+**典型场景说明**：
+1. **场景1：单个继电器控制**
+   - 按下开关 → 继电器动作 → LED反馈加入全局队列 → 30ms后发送
+
+2. **场景2：批量控制（如17通道全开，16个继电器）**
+   - 触发17通道 → 1-16路继电器全开 → 所有绑定的LED反馈加入全局队列
+   - 假设每个继电器绑定2个开关面板 = 32个LED反馈
+   - 按加入队列的顺序依次发送，耗时约960ms（30ms×32）
+
+3. **场景3：快速切换（如17通道全开后立即18通道全关）**
+   - 17通道触发 → 1-16路全开 → 32个LED反馈加入队列
+   - 18通道触发 → 1-16路全关 → 32个LED反馈加入队列
+   - 全局队列按顺序处理，确保所有面板最终显示正确状态
+
+4. **场景4：双控开关（1个继电器绑定2个不同ID的开关面板）**
+   - 继电器状态变化 → 2个LED反馈加入全局队列
+   - 按顺序发送，间隔30ms，确保所有面板LED状态同步
+
+5. **场景5：大规模部署（50个8键开关 = 400个按键）**
+   - 批量控制触发 → 所有LED反馈加入全局队列
+   - 按部署时的节点顺序依次发送，耗时约12秒（30ms×400）
+   - 确保总线稳定，不会冲突或丢失
 
 ## 许可证
 

package/examples/basic-flow.json

@@ -2,11 +2,22 @@
     {
         "id": "modbus_server_config_1",
         "type": "modbus-server-config",
-        "name": "Modbus服务器",
+        "name": "Modbus服务器（TCP）",
         "connectionType": "tcp",
-        "tcpHost": "127.0.0.1",
+        "tcpHost": "192.168.1.100",
         "tcpPort": "502"
     },
+    {
+        "id": "serial_port_config_1",
+        "type": "serial-port-config",
+        "name": "RS-485串口",
+        "connectionType": "serial",
+        "serialPort": "/dev/ttyUSB0",
+        "baudRate": "9600",
+        "dataBits": "8",
+        "parity": "none",
+        "stopBits": "1"
+    },
     {
         "id": "modbus_master_1",
         "type": "modbus-master",
@@ -124,14 +135,14 @@
         "id": "switch_node_1",
         "type": "modbus-slave-switch",
         "name": "面板1按键1（开关模式）",
-        "serialPortConfig": "",
+        "serialPortConfig": "serial_port_config_1",
         "mqttServer": "",
         "switchBrand": "symi",
         "buttonType": "switch",
         "switchId": "1",
         "buttonNumber": "1",
         "targetSlaveAddress": "10",
-        "targetCoilNumber": "1",
+        "targetCoilNumber": "0",
         "x": 340,
         "y": 300,
         "wires": [["debug_2"]]
@@ -194,14 +205,14 @@
         "id": "switch_node_2",
         "type": "modbus-slave-switch",
         "name": "面板1按键2（场景模式）",
-        "serialPortConfig": "",
+        "serialPortConfig": "serial_port_config_1",
         "mqttServer": "",
         "switchBrand": "symi",
         "buttonType": "scene",
         "switchId": "1",
         "buttonNumber": "2",
         "targetSlaveAddress": "10",
-        "targetCoilNumber": "2",
+        "targetCoilNumber": "1",
         "x": 340,
         "y": 360,
         "wires": [["debug_3"]]

package/nodes/modbus-master.js

@@ -150,7 +150,7 @@ module.exports = function(RED) {
         // 写入队列机制（确保所有写入操作串行执行，避免锁竞争）
         node.writeQueue = []; // 写入队列
         node.isProcessingWrite = false; // 是否正在处理写入队列
-        node.writeQueueInterval = 50; // 写入队列处理间隔（50ms，确保总线稳定，避免数据丢失）
+        node.writeQueueInterval = 30; // 写入队列处理间隔（30ms，确保总线稳定，避免数据丢失）
 
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
@@ -1197,7 +1197,7 @@ module.exports = function(RED) {
                     node.warn(`队列任务失败，继续处理下一个任务: ${err.message}`);
                 }
 
-                // 等待一段时间再处理下一个任务（20ms间隔，确保总线稳定）
+                // 等待一段时间再处理下一个任务（30ms间隔，确保总线稳定）
                 if (node.writeQueue.length > 0) {
                     await new Promise(resolve => setTimeout(resolve, node.writeQueueInterval));
                 }

package/nodes/modbus-slave-switch.js

@@ -379,12 +379,11 @@ module.exports = function(RED) {
         node.commandQueue = [];
         node.isProcessingCommand = false;
 
-        // 指示灯反馈队列（40ms间隔发送）- 带时间戳
-        node.ledFeedbackQueue = [];
-        node.isProcessingLedFeedback = false;
-
-        // 队列超时时间（3秒）
-        node.queueTimeout = 3000;
+        // LED反馈去重：记录最后一次发送的状态和时间戳（防止重复发送）
+        node.lastSentLedState = {
+            value: null,
+            timestamp: 0
+        };
 
         // 防死循环：记录最后一次状态变化的时间戳和值
         node.lastStateChange = {
@@ -392,12 +391,6 @@ module.exports = function(RED) {
             value: false
         };
 
-        // 防止LED反馈重复发送：记录最后一次LED反馈的时间戳和值
-        node.lastLedFeedback = {
-            timestamp: 0,
-            value: false
-        };
-
         // 节点初始化标志（用于静默初始化期间的警告）
         node.isInitializing = true;
 
@@ -504,8 +497,6 @@ module.exports = function(RED) {
                 // 结束初始化阶段（5秒后）- 避免部署时大量LED反馈同时发送
                 setTimeout(() => {
                     node.isInitializing = false;
-                    // 初始化完成后，处理积累的LED反馈队列
-                    node.processLedFeedbackQueue();
                 }, 5000);
 
                 // 监听物理开关面板的按键事件
@@ -797,7 +788,8 @@ module.exports = function(RED) {
             node.isProcessingCommand = false;
         };
         
-        // 发送控制指令到物理开关面板（控制指示灯等）- 入队
+        // 发送控制指令到物理开关面板（控制指示灯等）
+        // 直接发送到全局队列，由serial-port-config统一管理（20ms间隔串行发送）
         node.sendCommandToPanel = function(state) {
             // 检查连接状态
             if (!node.serialPortConfig || !node.serialPortConfig.connection) {
@@ -808,161 +800,83 @@ module.exports = function(RED) {
                 return;
             }
 
-            // 防止重复发送：如果状态相同且时间间隔小于100ms，跳过
+            // 初始化期间不发送LED反馈（避免部署时大量LED同时发送）
+            if (node.isInitializing) {
+                return;
+            }
+
             const now = Date.now();
-            const timeSinceLastFeedback = now - node.lastLedFeedback.timestamp;
-            const stateChanged = (state !== node.lastLedFeedback.value);
 
-            if (!stateChanged && timeSinceLastFeedback < 100) {
-                node.debug(`跳过重复LED反馈（状态未变化，间隔${timeSinceLastFeedback}ms）`);
+            // 防止重复发送：如果状态相同且时间间隔小于50ms，跳过
+            if (node.lastSentLedState.value === state && (now - node.lastSentLedState.timestamp) < 50) {
+                node.debug(`跳过重复LED反馈（状态未变化，间隔${now - node.lastSentLedState.timestamp}ms）`);
                 return;
             }
 
-            // 智能队列管理：优先最新状态
-            // 1. 如果队列中最后一个状态与新状态相同，跳过（避免重复）
-            // 2. 如果队列中最后一个状态与新状态不同，清空队列并添加新状态（确保最新状态优先）
-            if (node.ledFeedbackQueue.length > 0) {
-                const lastQueuedState = node.ledFeedbackQueue[node.ledFeedbackQueue.length - 1].state;
-                if (lastQueuedState === state) {
-                    node.debug(`队列中最后一个状态已是${state ? 'ON' : 'OFF'}，跳过添加`);
+            // 更新最后发送状态
+            node.lastSentLedState.value = state;
+            node.lastSentLedState.timestamp = now;
+
+            // 构建LED反馈协议帧
+            let command;
+
+            if (node.config.buttonType === 'mesh') {
+                // Mesh模式：发送Mesh控制帧
+                command = meshProtocol.buildSwitchControlFrame(
+                    node.config.meshShortAddress,
+                    node.config.meshButtonNumber,
+                    node.config.meshTotalButtons,
+                    state,
+                    node.meshCurrentStates || null
+                );
+
+                if (!command) {
+                    node.error(`构建Mesh控制帧失败`);
                     return;
+                }
+            } else {
+                // RS-485模式：使用轻量级协议
+                const deviceAddr = node.buttonDeviceAddr;
+                const channel = node.buttonChannel;
+
+                // 根据按钮类型选择协议类型
+                if (node.config.buttonType === 'scene') {
+                    // 场景模式：使用REPORT协议
+                    command = protocol.buildSingleLightReport(
+                        node.config.switchId,
+                        deviceAddr,
+                        channel,
+                        state
+                    );
                 } else {
-                    // 状态发生变化，清空旧队列，使用最新状态（确保面板显示最新状态）
-                    node.debug(`状态变化：${lastQueuedState ? 'ON' : 'OFF'} → ${state ? 'ON' : 'OFF'}，清空旧队列，优先最新状态`);
-                    node.ledFeedbackQueue = [];
+                    // 开关模式（默认）：使用SET协议
+                    command = protocol.buildSingleLightCommand(
+                        node.config.switchId,
+                        deviceAddr,
+                        channel,
+                        state
+                    );
                 }
             }
 
-            // 加入LED反馈队列（带时间戳）
-            node.ledFeedbackQueue.push({ state, timestamp: now });
-
-            // 启动队列处理
-            node.processLedFeedbackQueue();
-        };
-        
-        // 处理LED反馈队列（20ms间隔串行发送）
-        node.processLedFeedbackQueue = async function() {
-            if (node.isProcessingLedFeedback || node.ledFeedbackQueue.length === 0) {
-                return;
-            }
-
-            // 初始化期间不处理LED反馈（避免部署时大量LED同时发送）
-            if (node.isInitializing) {
-                return;
-            }
-
-            node.isProcessingLedFeedback = true;
-
-            // 清理过期队列项
-            const now = Date.now();
-            node.ledFeedbackQueue = node.ledFeedbackQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
-
-            // 记录队列开始处理时间
-            const queueStartTime = Date.now();
-            const queueLength = node.ledFeedbackQueue.length;
-
-            while (node.ledFeedbackQueue.length > 0) {
-                const item = node.ledFeedbackQueue.shift();
-
-                // 再次检查是否过期
-                if (Date.now() - item.timestamp >= node.queueTimeout) {
-                    node.warn(`丢弃过期LED反馈（${Date.now() - item.timestamp}ms）`);
-                    continue;
-                }
-
-                const state = item.state;
-
-                try {
-                    let command;
-
+            // 直接发送到全局队列（由serial-port-config统一管理，20ms间隔串行发送）
+            node.serialPortConfig.write(command, (err) => {
+                if (err) {
+                    node.error(`LED反馈失败: ${err.message}`);
+                } else {
+                    // 输出调试日志，确认LED反馈已发送（包含协议帧十六进制）
+                    const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
                     if (node.config.buttonType === 'mesh') {
-                        // Mesh模式：发送Mesh控制帧
-                        command = meshProtocol.buildSwitchControlFrame(
-                            node.config.meshShortAddress,
-                            node.config.meshButtonNumber,
-                            node.config.meshTotalButtons,
-                            state,
-                            node.meshCurrentStates || null
-                        );
-
-                        if (!command) {
-                            node.error(`构建Mesh控制帧失败`);
-                            continue;
-                        }
+                        node.log(`Mesh LED反馈已发送：MAC=${node.config.meshMacAddress} 按钮${node.config.meshButtonNumber} = ${state ? 'ON' : 'OFF'} [${hexStr}]`);
                     } else {
-                        // RS-485模式：使用轻量级协议
-                        // 使用初始化时计算的deviceAddr和channel
-                        // 当物理按键按下时，会更新为实际的deviceAddr和channel
                         const deviceAddr = node.buttonDeviceAddr;
                         const channel = node.buttonChannel;
-
-                        // 根据按钮类型选择协议类型
-                        // 开关模式：使用SET协议（0x03），面板LED需要接收SET指令
-                        // 场景模式：使用REPORT协议（0x04），面板LED需要接收REPORT指令
-                        if (node.config.buttonType === 'scene') {
-                            // 场景模式：使用REPORT协议
-                            command = protocol.buildSingleLightReport(
-                                node.config.switchId,  // 本地地址（面板地址）
-                                deviceAddr,            // 设备地址（从按键事件中获取）
-                                channel,               // 通道（从按键事件中获取）
-                                state
-                            );
-                        } else {
-                            // 开关模式（默认）：使用SET协议
-                            command = protocol.buildSingleLightCommand(
-                                node.config.switchId,  // 本地地址（面板地址）
-                                deviceAddr,            // 设备地址（从按键事件中获取）
-                                channel,               // 通道（从按键事件中获取）
-                                state
-                            );
-                        }
+                        node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
                     }
-
-                    // 发送到RS-485总线或Mesh网关（使用共享连接配置）
-                    if (node.serialPortConfig) {
-                        node.serialPortConfig.write(command, (err) => {
-                            if (err) {
-                                node.error(`LED反馈失败: ${err.message}`);
-                            } else {
-                                // 记录最后一次LED反馈的时间戳和值
-                                node.lastLedFeedback.timestamp = Date.now();
-                                node.lastLedFeedback.value = state;
-
-                                // 输出调试日志，确认LED反馈已发送（包含协议帧十六进制）
-                                const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
-                                if (node.config.buttonType === 'mesh') {
-                                    node.log(`Mesh LED反馈已发送：MAC=${node.config.meshMacAddress} 按钮${node.config.meshButtonNumber} = ${state ? 'ON' : 'OFF'} [${hexStr}]`);
-                                } else {
-                                    const deviceAddr = node.buttonDeviceAddr;
-                                    const channel = node.buttonChannel;
-                                    node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
-                                }
-                            }
-                        });
-                    } else {
-                        node.warn('连接未配置');
-                    }
-
-                    // 队列间隔20ms（优化速度，确保200个节点能快速反馈）
-                    // 20ms × 200节点 = 4秒完成所有反馈
-                    if (node.ledFeedbackQueue.length > 0) {
-                        await new Promise(resolve => setTimeout(resolve, 20));
-                    }
-                } catch (err) {
-                    node.error(`发送LED反馈失败: ${err.message}`);
-                    // LED反馈失败不中断队列，继续处理下一个
                 }
-            }
-
-            // 队列处理完成，输出统计信息
-            const queueDuration = Date.now() - queueStartTime;
-            if (queueLength > 1) {
-                node.debug(`LED反馈队列处理完成：${queueLength}个任务，耗时${queueDuration}ms`);
-            }
-
-            node.isProcessingLedFeedback = false;
+            });
         };
-        
+
         // 更新节点状态显示
         node.updateStatus = function() {
             const rs485Status = node.isRs485Connected ? 'OK' : 'ERR';
@@ -1290,7 +1204,6 @@ module.exports = function(RED) {
             
             // 清理队列（释放内存）
             node.commandQueue = [];
-            node.ledFeedbackQueue = [];
             node.frameBuffer = Buffer.alloc(0);
             
             // 注销RS-485数据监听器（不关闭连接，由配置节点管理）

package/nodes/serial-port-config.js

@@ -405,9 +405,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // TCP写入间隔（20ms，避免网关处理不过来）
+                        // TCP写入间隔（30ms，避免网关处理不过来）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 20));
+                            await new Promise(resolve => setTimeout(resolve, 30));
                         }
                     } else {
                         if (!node.connection.isOpen) {
@@ -439,9 +439,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // 串口写入间隔（10ms，串口速度较快）
+                        // 串口写入间隔（30ms，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 10));
+                            await new Promise(resolve => setTimeout(resolve, 30));
                         }
                     }
                 } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.7.8",
+  "version": "2.8.0",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {