node-red-contrib-symi-modbus 2.6.1 → 2.6.2

package/README.md

@@ -231,8 +231,14 @@ node-red-restart
 - **内存管理**：自动清理缓存，释放无用对象
 - **事件监听器清理**：关闭时移除所有监听器，防止内存泄漏
 - **智能日志限流**：错误日志10分钟输出一次，避免日志刷屏
-- **自动重连**：Modbus和MQTT断线自动重连（5秒间隔）
+- **智能重连机制**：
+  - Modbus连接断开自动重连（指数退避：5秒→10秒→20秒...最大60秒）
+  - MQTT连接断开自动重连（支持多地址fallback）
+  - 串口拔插自动检测并重连
+  - TCP网络故障自动恢复
+  - 连接前彻底清理旧实例，避免资源泄漏
 - **互斥锁机制**：防止读写冲突导致的数据异常
+- **Keep-Alive心跳**：TCP连接启用30秒心跳检测
 
 ## 技术规格
 
@@ -435,7 +441,7 @@ msg.payload = 1;      // 或 0
 
 ## 项目信息
 
-**版本**: v2.6.1
+**版本**: v2.6.2
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
@@ -445,7 +451,7 @@ msg.payload = 1;      // 或 0
 - MQTT集成（Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
 - 物理开关面板双向同步（亖米协议支持，LED反馈同步）
 - 共享连接架构（多个从站开关节点共享同一个串口/TCP连接，支持500+节点）
-- 长期稳定运行（内存管理、自动重连、错误日志限流、异步MQTT发布）
+- 长期稳定运行（内存管理、智能重连、错误日志限流、异步MQTT发布）
 
 **技术栈**：
 - modbus-serial: ^8.0.23（内部封装serialport，支持TCP和串口）
@@ -454,34 +460,26 @@ msg.payload = 1;      // 或 0
 - Node.js: >=14.0.0
 - Node-RED: >=2.0.0
 
-**最新更新（v2.6.1）**：
-- **串口自动重连**：断开后5秒自动重连，确保长期稳定运行
-- **连接状态管理**：完善的串口和TCP连接状态监控
-- **错误恢复**：串口拔插后自动恢复，无需重启Node-RED
-
-**v2.6.0更新**：
-- **双模式支持**：完整支持开关按钮和场景按钮两种模式
-  - 开关按钮：独立开/关控制 + SET协议LED反馈
-  - 场景按钮：Toggle切换控制 + REPORT协议LED反馈
-- **精确LED反馈**：使用原始设备地址和通道，确保LED反馈到正确按键
-- **完美状态同步**：
-  - 物理按键控制 → LED同步 ✓
-  - Home Assistant远程控制 → LED同步 ✓
-  - 双向同步，实时响应
-- **协议优化**：
-  - 开关模式使用SET协议（0x03）
-  - 场景模式使用REPORT协议（0x04）
-  - 自动fallback机制确保HA远程控制正常
-- **性能提升**：
-  - 全局防抖机制（200ms）避免重复触发
-  - 基于面板ID的固定延迟避免TCP冲突
-  - 防死循环机制确保系统稳定
-  - 支持500+节点大规模部署
-- **用户体验**：
-  - 继电器路数优化：直接输入1-32路
-  - 完善串口配置：支持所有串口参数
-  - 智能日志输出：减少系统负担
-  - 长期稳定运行：工控机7x24小时验证
+**最新更新（v2.6.2）**：
+- **🔥 智能重连机制**：全面优化的连接恢复系统
+  - 串口拔插自动重连：检测到串口断开后自动尝试重连，支持热插拔
+  - TCP断网自动重连：网络故障恢复后自动重新建立连接
+  - 指数退避策略：重连间隔智能调整（5秒→10秒→20秒→40秒→最大60秒）
+  - 连接状态完全释放：重连前彻底清理旧连接，避免资源泄漏
+  - Keep-Alive心跳：TCP连接启用30秒心跳检测，及时发现网络故障
+  - 错误类型识别：准确识别8种连接错误类型，精准触发重连
+- **长期稳定性保障**：
+  - 完善的连接生命周期管理，避免资源泄漏
+  - 节点关闭时自动清除所有定时器和监听器
+  - 重连定时器严格管理，避免重复创建
+  - 支持长期运行（测试验证：串口拔插后自动重连成功）
+
+**v2.6.0-v2.6.1更新**：
+- 双模式支持：完整支持开关按钮和场景按钮两种模式
+- 精确LED反馈：使用原始设备地址和通道，确保LED反馈到正确按键
+- 完美状态同步：物理按键和HA远程控制双向同步
+- 性能提升：全局防抖、智能日志、互斥锁机制
+- 用户体验：继电器路数优化、串口配置完善
 
 **性能优化**：
 - 轮询间隔优化：修复间隔计算逻辑，确保每个从站使用正确的轮询间隔

package/nodes/modbus-master.js

@@ -131,6 +131,7 @@ module.exports = function(RED) {
         node.isConnected = false;
         node.pollTimer = null;
         node.reconnectTimer = null;
+        node.reconnectAttempts = 0;  // 重连尝试次数
         node.currentSlaveIndex = 0;
         node.deviceStates = {}; // 存储每个设备的状态
         node.mqttClient = null;
@@ -176,6 +177,29 @@ module.exports = function(RED) {
         
         // 连接Modbus
         node.connectModbus = async function() {
+            // 清除旧的重连定时器
+            if (node.reconnectTimer) {
+                clearTimeout(node.reconnectTimer);
+                node.reconnectTimer = null;
+            }
+
+            // 关闭旧连接（确保完全释放）
+            if (node.client && node.client.isOpen) {
+                try {
+                    node.log('关闭旧的Modbus连接...');
+                    await new Promise((resolve) => {
+                        node.client.close(() => {
+                            resolve();
+                        });
+                    });
+                } catch (err) {
+                    node.warn(`关闭旧连接时出错: ${err.message}`);
+                }
+            }
+
+            // 创建新的Modbus客户端实例
+            node.client = new ModbusRTU();
+
             try {
                 if (node.config.connectionType === "tcp") {
                     // 验证TCP主机地址
@@ -208,12 +232,15 @@ module.exports = function(RED) {
 
                     node.log(`TCP网关连接成功（${modeNames[tcpMode]}）: ${node.config.tcpHost}:${node.config.tcpPort}`);
                 } else {
+                    node.log(`正在连接串口: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps...`);
+                    
                     await node.client.connectRTUBuffered(node.config.serialPort, {
                         baudRate: node.config.serialBaudRate || 9600,
                         dataBits: node.config.serialDataBits || 8,
                         stopBits: node.config.serialStopBits || 1,
                         parity: node.config.serialParity || 'none'
                     });
+                    
                     node.log(`串口Modbus连接成功: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);
                 }
 
@@ -221,7 +248,9 @@ module.exports = function(RED) {
                 const timeout = node.config.connectionType === "serial" ? 10000 : 5000;
                 node.client.setTimeout(timeout);
                 node.log(`Modbus超时设置: ${timeout}ms`);
+                
                 node.isConnected = true;
+                node.reconnectAttempts = 0;  // 重置重连计数
                 node.log(`Modbus已连接: ${node.config.connectionType === "tcp" ? `${node.config.tcpHost}:${node.config.tcpPort}` : node.config.serialPort}`);
                 node.updateNodeStatus();
 
@@ -239,7 +268,6 @@ module.exports = function(RED) {
                 }
 
                 // 立即启动轮询（不等待MQTT连接）
-                // 修复：确保轮询在Modbus连接成功后立即启动，不依赖MQTT状态
                 if (!node.pollTimer) {
                     node.log('Modbus连接成功，立即启动轮询...');
                     node.startPolling();
@@ -252,12 +280,17 @@ module.exports = function(RED) {
                 node.isConnected = false;
                 node.updateNodeStatus();
                 
-                // 5秒后重试连接（使用定时器避免递归）
+                // 使用指数退避策略重试（5秒、10秒、20秒...最大60秒）
                 if (!node.isClosing && !node.reconnectTimer) {
+                    const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);
+                    node.reconnectAttempts++;
+                    
+                    node.log(`${delay/1000}秒后重试Modbus连接（第${node.reconnectAttempts}次）...`);
+                    
                     node.reconnectTimer = setTimeout(() => {
                         node.reconnectTimer = null;
                         node.connectModbus();
-                    }, 5000);
+                    }, delay);
                 }
             }
         };
@@ -913,12 +946,18 @@ module.exports = function(RED) {
                 node.updateNodeStatus();
 
                 // 检测是否是连接断开错误
-                if (err.message &&
-                    (err.message.includes('ECONNRESET') ||
-                     err.message.includes('ETIMEDOUT') ||
-                     err.message.includes('ENOTCONN') ||
-                     err.message.includes('Port Not Open'))) {
+                const isConnectionError = err.message && (
+                    err.message.includes('ECONNRESET') ||
+                    err.message.includes('ETIMEDOUT') ||
+                    err.message.includes('ENOTCONN') ||
+                    err.message.includes('ECONNREFUSED') ||
+                    err.message.includes('EHOSTUNREACH') ||
+                    err.message.includes('Port Not Open') ||
+                    err.message.includes('Port is not open') ||
+                    err.message.includes('Cannot call write')
+                );
 
+                if (isConnectionError) {
                     // 连接断开，尝试重连
                     if (shouldLog) {
                         node.warn('检测到连接断开，尝试重连...');
@@ -936,12 +975,17 @@ module.exports = function(RED) {
                         }
                     }
 
-                    // 尝试重连
+                    // 使用指数退避策略重连
                     if (!node.isClosing && !node.reconnectTimer) {
+                        const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);
+                        node.reconnectAttempts++;
+                        
+                        node.log(`${delay/1000}秒后重试Modbus连接（第${node.reconnectAttempts}次）...`);
+                        
                         node.reconnectTimer = setTimeout(() => {
                             node.reconnectTimer = null;
                             node.connectModbus();
-                        }, 5000);
+                        }, delay);
                     }
                 }
             }

package/nodes/serial-port-config.js

@@ -26,6 +26,8 @@ module.exports = function(RED) {
         node.connection = null;  // TCP socket 或 SerialPort
         node.isOpening = false;  // 标记是否正在打开连接
         node.isClosing = false;  // 标记节点是否正在关闭
+        node.reconnectTimer = null;  // 重连定时器
+        node.reconnectAttempts = 0;  // 重连尝试次数
 
         // 数据监听器列表（每个从站开关节点注册一个）
         node.dataListeners = [];
@@ -37,11 +39,20 @@ module.exports = function(RED) {
                 return;
             }
 
+            // 清除旧的重连定时器
+            if (node.reconnectTimer) {
+                clearTimeout(node.reconnectTimer);
+                node.reconnectTimer = null;
+            }
+
             try {
                 node.connection = new net.Socket();
+                node.connection.setKeepAlive(true, 30000);  // 启用TCP Keep-Alive，30秒间隔
+                node.connection.setTimeout(60000);  // 60秒超时
 
                 node.connection.connect(node.tcpPort, node.tcpHost, () => {
                     node.log(`TCP连接已建立: ${node.tcpHost}:${node.tcpPort}`);
+                    node.reconnectAttempts = 0;  // 重置重连计数
                 });
 
                 // 监听数据（分发给所有注册的监听器）
@@ -56,21 +67,43 @@ module.exports = function(RED) {
                     });
                 });
 
+                // 监听超时
+                node.connection.on('timeout', () => {
+                    node.warn('TCP连接超时，尝试重连...');
+                    if (node.connection) {
+                        node.connection.destroy();
+                    }
+                });
+
                 // 监听错误
                 node.connection.on('error', (err) => {
                     node.error(`TCP连接错误: ${err.message}`);
+                    // 不在这里重连，在close事件中统一处理
                 });
 
-                // 监听关闭
-                node.connection.on('close', () => {
-                    node.log('TCP连接已关闭');
-                    // 自动重连
-                    setTimeout(() => {
-                        if (node.dataListeners.length > 0) {
-                            node.log('尝试重新连接TCP...');
+                // 监听关闭（统一的重连入口）
+                node.connection.on('close', (hadError) => {
+                    node.log(`TCP连接已关闭${hadError ? '（有错误）' : ''}`);
+                    
+                    // 清理连接对象
+                    if (node.connection) {
+                        node.connection.removeAllListeners();
+                        node.connection.destroy();
+                        node.connection = null;
+                    }
+                    
+                    // 自动重连（如果不是主动关闭且有监听器在使用）
+                    if (!node.isClosing && node.dataListeners.length > 0) {
+                        const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);  // 指数退避，最大60秒
+                        node.reconnectAttempts++;
+                        
+                        node.log(`${delay/1000}秒后尝试重新连接TCP（第${node.reconnectAttempts}次）...`);
+                        
+                        node.reconnectTimer = setTimeout(() => {
+                            node.reconnectTimer = null;
                             node.openTcpConnection();
-                        }
-                    }, 5000);
+                        }, delay);
+                    }
                 });
             } catch (err) {
                 node.error(`TCP连接初始化失败: ${err.message}`);
@@ -89,6 +122,25 @@ module.exports = function(RED) {
                 return;
             }
 
+            // 清除旧的重连定时器
+            if (node.reconnectTimer) {
+                clearTimeout(node.reconnectTimer);
+                node.reconnectTimer = null;
+            }
+
+            // 清理旧的串口实例（确保完全释放）
+            if (node.connection) {
+                try {
+                    node.connection.removeAllListeners();
+                    if (node.connection.isOpen) {
+                        node.connection.close();
+                    }
+                } catch (err) {
+                    // 忽略清理错误
+                }
+                node.connection = null;
+            }
+
             node.isOpening = true;
 
             try {
@@ -107,10 +159,24 @@ module.exports = function(RED) {
 
                     if (err) {
                         node.error(`串口打开失败: ${err.message}`);
+                        
+                        // 打开失败时也要触发重连（如果有监听器在使用）
+                        if (!node.isClosing && node.dataListeners.length > 0) {
+                            const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);
+                            node.reconnectAttempts++;
+                            
+                            node.log(`${delay/1000}秒后尝试重新打开串口（第${node.reconnectAttempts}次）...`);
+                            
+                            node.reconnectTimer = setTimeout(() => {
+                                node.reconnectTimer = null;
+                                node.openSerialConnection();
+                            }, delay);
+                        }
                         return;
                     }
 
                     node.log(`串口已打开: ${node.serialPort} @ ${node.baudRate}bps ${node.dataBits}${node.parity.charAt(0).toUpperCase()}${node.stopBits}`);
+                    node.reconnectAttempts = 0;  // 重置重连计数
 
                     // 监听数据（分发给所有注册的监听器）
                     node.connection.on('data', (data) => {
@@ -127,27 +193,55 @@ module.exports = function(RED) {
                     // 监听错误
                     node.connection.on('error', (err) => {
                         node.error(`串口错误: ${err.message}`);
+                        // 不在这里重连，在close事件中统一处理
                     });
 
-                    // 监听关闭
-                    node.connection.on('close', () => {
-                        node.log('串口已关闭');
-                        // 自动重连（如果还有监听器在使用）
-                        setTimeout(() => {
-                            if (node.dataListeners.length > 0 && !node.isClosing) {
-                                node.log('检测到串口断开，5秒后尝试重新连接...');
-                                node.openSerialConnection();
+                    // 监听关闭（统一的重连入口）
+                    node.connection.on('close', (err) => {
+                        if (err) {
+                            node.log(`串口已关闭（错误: ${err.message}）`);
+                        } else {
+                            node.log('串口已关闭');
+                        }
+                        
+                        // 清理连接对象
+                        if (node.connection) {
+                            try {
+                                node.connection.removeAllListeners();
+                            } catch (e) {
+                                // 忽略清理错误
                             }
-                        }, 5000);
-                    });
-
-                    // 监听断开连接
-                    node.connection.on('disconnect', () => {
-                        node.log('串口设备已拔出');
+                            node.connection = null;
+                        }
+                        
+                        // 自动重连（如果不是主动关闭且有监听器在使用）
+                        if (!node.isClosing && node.dataListeners.length > 0) {
+                            const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);  // 指数退避，最大60秒
+                            node.reconnectAttempts++;
+                            
+                            node.log(`检测到串口断开，${delay/1000}秒后尝试重新连接（第${node.reconnectAttempts}次）...`);
+                            
+                            node.reconnectTimer = setTimeout(() => {
+                                node.reconnectTimer = null;
+                                node.openSerialConnection();
+                            }, delay);
+                        }
                     });
                 });
             } catch (err) {
+                node.isOpening = false;
                 node.error(`串口初始化失败: ${err.message}`);
+                
+                // 初始化失败时也要触发重连
+                if (!node.isClosing && node.dataListeners.length > 0) {
+                    const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);
+                    node.reconnectAttempts++;
+                    
+                    node.reconnectTimer = setTimeout(() => {
+                        node.reconnectTimer = null;
+                        node.openSerialConnection();
+                    }, delay);
+                }
             }
         };
 
@@ -241,25 +335,46 @@ module.exports = function(RED) {
         node.on('close', function(done) {
             node.isClosing = true;  // 标记正在关闭，防止自动重连
             
+            // 清除重连定时器
+            if (node.reconnectTimer) {
+                clearTimeout(node.reconnectTimer);
+                node.reconnectTimer = null;
+            }
+            
             // 清空所有监听器
             node.dataListeners = [];
 
             // 关闭连接
             if (node.connection) {
                 if (node.connectionType === 'tcp') {
-                    if (!node.connection.destroyed) {
-                        node.connection.destroy();
+                    try {
+                        node.connection.removeAllListeners();
+                        if (!node.connection.destroyed) {
+                            node.connection.destroy();
+                        }
+                    } catch (err) {
+                        node.warn(`关闭TCP连接时出错: ${err.message}`);
                     }
+                    node.connection = null;
                     done();
                 } else {
-                    if (node.connection.isOpen) {
-                        node.connection.close((err) => {
-                            if (err) {
-                                node.error(`串口关闭失败: ${err.message}`);
-                            }
+                    try {
+                        node.connection.removeAllListeners();
+                        if (node.connection.isOpen) {
+                            node.connection.close((err) => {
+                                if (err) {
+                                    node.error(`串口关闭失败: ${err.message}`);
+                                }
+                                node.connection = null;
+                                done();
+                            });
+                        } else {
+                            node.connection = null;
                             done();
-                        });
-                    } else {
+                        }
+                    } catch (err) {
+                        node.warn(`关闭串口连接时出错: ${err.message}`);
+                        node.connection = null;
                         done();
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、智能MQTT连接（自动fallback HassOS/Docker环境）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {