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

package/README.md

@@ -18,7 +18,10 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成。
 - **32路继电器**：每台设备支持32个线圈（继电器通道）
 - **智能轮询**：从站上报时自动暂停轮询，优先处理数据，完成后继续轮询
 - **灵活配置**：可自定义轮询间隔（100-10000ms，默认200ms）、线圈范围、从站地址
-- **MQTT集成**：自动生成Home Assistant兼容的MQTT发现消息
+- **🔥 双模式支持**：
+  - **本地模式**：纯串口通信，无需MQTT，断网也能稳定运行
+  - **MQTT模式**：可选接入Home Assistant等第三方平台
+- **MQTT集成**（可选）：自动生成Home Assistant兼容的MQTT发现消息
 - **实时状态**：实时监控和控制继电器状态
 - **主从模式**：提供主站节点和从站控制节点
 - **稳定可靠**：完整的内存管理和错误处理，适合工控机长期稳定运行
@@ -39,8 +42,36 @@ node-red-restart
 2. 搜索 `node-red-contrib-symi-modbus`
 3. 点击安装
 
-### 2. 配置MQTT服务器
+### 2. 选择运行模式
 
+本节点支持两种运行模式，根据需求选择：
+
+#### 模式1：本地模式（推荐用于纯串口控制）
+
+**适用场景**：
+- 无需对接第三方平台
+- 断网环境下稳定运行
+- 纯本地化控制，不受网络影响
+
+**配置方法**：
+1. 主站节点：不启用MQTT或不配置MQTT服务器
+2. 从站开关节点：不配置MQTT服务器
+3. 将从站开关节点的输出连线到主站节点的输入
+
+**优势**：
+- ✅ 断网也能稳定运行
+- ✅ 不依赖外部服务
+- ✅ 响应速度更快
+- ✅ 配置更简单
+
+#### 模式2：MQTT模式（推荐用于Home Assistant集成）
+
+**适用场景**：
+- 需要对接Home Assistant等平台
+- 需要远程控制
+- 需要状态持久化
+
+**配置方法**：
 1. 拖拽任意节点到流程画布
 2. 双击节点，找到"MQTT服务器"字段
 3. 点击编辑按钮，填写MQTT服务器信息：
@@ -48,6 +79,11 @@ node-red-restart
    - 用户名/密码: 按需填写
    - 基础主题: `modbus/relay` (默认)
 
+**优势**：
+- ✅ Home Assistant自动发现
+- ✅ 支持远程控制
+- ✅ 状态持久化存储
+
 ### 3. 配置主站节点
 
 1. 拖拽 **Modbus主站** 节点到流程画布
@@ -71,7 +107,9 @@ node-red-restart
    - 从站地址: `10` (默认，可添加多个，如10、11、12、13)
    - 线圈范围: `0-31`
    - 轮询间隔: `200ms` (默认，支持100-10000ms)
-4. 启用MQTT并选择MQTT服务器配置
+4. MQTT配置（可选）：
+   - 本地模式：不启用MQTT或留空
+   - MQTT模式：启用MQTT并选择MQTT服务器配置
 5. 部署流程
 
 ### 4. 配置RS-485连接配置节点（用于从站开关）
@@ -231,8 +269,14 @@ node-red-restart
 - **内存管理**：自动清理缓存，释放无用对象
 - **事件监听器清理**：关闭时移除所有监听器，防止内存泄漏
 - **智能日志限流**：错误日志10分钟输出一次，避免日志刷屏
-- **自动重连**：Modbus和MQTT断线自动重连（5秒间隔）
+- **智能重连机制**：
+  - Modbus连接断开自动重连（指数退避：5秒→10秒→20秒...最大60秒）
+  - MQTT连接断开自动重连（支持多地址fallback）
+  - 串口拔插自动检测并重连
+  - TCP网络故障自动恢复
+  - 连接前彻底清理旧实例，避免资源泄漏
 - **互斥锁机制**：防止读写冲突导致的数据异常
+- **Keep-Alive心跳**：TCP连接启用30秒心跳检测
 
 ## 技术规格
 
@@ -435,53 +479,40 @@ msg.payload = 1;      // 或 0
 
 ## 项目信息
 
-**版本**: v2.6.1
+**版本**: v2.6.3
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
 - 多设备轮询（最多10台从站，每台32路继电器，轮询间隔100-10000ms可调）
 - Symi私有协议自动识别（支持两种485开关控制方式）
 - 智能轮询暂停机制（从站上报时自动暂停，处理完成后恢复）
-- MQTT集成（Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
+- 🔥 **双模式支持**（本地模式和MQTT模式可选切换，断网也能稳定运行）
+- MQTT集成（可选启用，Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
 - 物理开关面板双向同步（亖米协议支持，LED反馈同步）
 - 共享连接架构（多个从站开关节点共享同一个串口/TCP连接，支持500+节点）
-- 长期稳定运行（内存管理、自动重连、错误日志限流、异步MQTT发布）
+- 长期稳定运行（内存管理、智能重连、错误日志限流、异步MQTT发布）
 
 **技术栈**：
 - modbus-serial: ^8.0.23（内部封装serialport，支持TCP和串口）
 - serialport: ^12.0.0（原生串口通信）
-- mqtt: ^5.14.1（最新稳定版）
+- mqtt: ^5.14.1（最新稳定版，可选依赖）
 - 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.3）**：
+- **🔥 MQTT可选配置**：完全兼容无MQTT环境
+  - 本地模式：纯串口通信，断网也能稳定运行
+  - MQTT模式：可选接入Home Assistant等第三方平台
+  - 智能切换：MQTT断开时自动切换到本地模式
+  - 状态显示：清晰区分当前运行模式
+- **改进的错误提示**：
+  - MQTT未配置时不再报错，提示使用本地模式
+  - 友好的配置引导信息
+  - 更清晰的节点状态指示
+- **增强的稳定性**：
+  - 支持纯本地化部署，不受网络影响
+  - 工控机断网环境下持续稳定运行
+  - 保持所有原有功能的兼容性
 
 **性能优化**：
 - 轮询间隔优化：修复间隔计算逻辑，确保每个从站使用正确的轮询间隔

package/nodes/modbus-master.html

@@ -4,7 +4,7 @@
         color: '#3FADB5',
         defaults: {
             name: {value: "Modbus主站"},
-            modbusServer: {value: "", type: "modbus-server-config"},
+            modbusServer: {value: "", type: "modbus-server-config", required: true},
             // 从站配置列表（数组）
             slaves: {value: [{
                 address: 10,
@@ -12,9 +12,9 @@
                 coilEnd: 31,
                 pollInterval: 200
             }]},
-            // MQTT配置（引用config节点）
-            enableMqtt: {value: true},
-            mqttServer: {value: "", type: "mqtt-server-config"}
+            // MQTT配置（可选）
+            enableMqtt: {value: false},  // 默认不启用MQTT（本地模式）
+            mqttServer: {value: "", type: "mqtt-server-config", required: false}
         },
         inputs: 1,
         outputs: 1,
@@ -215,19 +215,25 @@
         </button>
     </div>
     
-    <!-- MQTT配置 -->
+    <!-- MQTT配置（可选） -->
     <hr style="margin: 15px 0; border: 0; border-top: 2px solid #e0e0e0;">
     <div class="form-row">
         <label style="width: 100%; margin-bottom: 8px;">
             <i class="fa fa-cloud" style="color: #ff9800;"></i> 
             <span style="font-size: 14px; font-weight: 600; color: #333;">MQTT集成配置</span>
+            <span style="margin-left: 8px; padding: 2px 8px; background: #e3f2fd; color: #1976d2; border-radius: 3px; font-size: 11px; font-weight: 500;">可选</span>
         </label>
+        <div style="font-size: 11px; color: #555; padding: 10px 12px; background: linear-gradient(135deg, #e8f5e9 0%, #f1f8f4 100%); border-left: 4px solid #4caf50; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.08); margin-bottom: 12px;">
+            <strong>💡 运行模式选择：</strong><br>
+            <strong style="color: #2e7d32;">本地模式</strong>（默认）：纯串口通信，断网也能稳定运行，不依赖外部服务<br>
+            <strong style="color: #1976d2;">MQTT模式</strong>：可接入Home Assistant等第三方平台，支持远程控制
+        </div>
     </div>
     
     <div class="form-row">
         <label for="node-input-enableMqtt" style="width: 110px;"><i class="fa fa-toggle-on"></i> 启用MQTT</label>
         <input type="checkbox" id="node-input-enableMqtt" style="width: auto; margin-left: 5px; transform: scale(1.3); cursor: pointer;">
-        <span style="margin-left: 15px; font-size: 11px; color: #666; font-style: italic;">用于Home Assistant集成和远程控制</span>
+        <span style="margin-left: 15px; font-size: 11px; color: #666; font-style: italic;">勾选后切换到MQTT模式</span>
     </div>
     
     <div class="form-row form-row-mqtt">

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);
                 }
             }
         };
@@ -339,13 +372,15 @@ module.exports = function(RED) {
         // 连接MQTT（带智能重试和fallback）
         node.connectMqtt = function() {
             if (!node.config.enableMqtt) {
-                node.log('MQTT未启用，跳过MQTT连接');
+                node.log('MQTT未启用 - 使用纯本地模式（仅串口通信）');
+                node.log('提示：如需Home Assistant集成，请在节点配置中启用MQTT');
                 return;
             }
             
             // 验证MQTT broker配置
             if (!node.config.mqttBroker || node.config.mqttBroker.trim() === '') {
-                node.warn('MQTT已启用但broker地址未配置，跳过MQTT连接');
+                node.warn('MQTT已启用但broker地址未配置 - 使用纯本地模式');
+                node.warn('提示：请在MQTT服务器配置节点中设置broker地址，或禁用MQTT功能');
                 return;
             }
             
@@ -913,12 +948,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 +977,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/modbus-slave-switch.html

@@ -5,9 +5,9 @@
         defaults: {
             name: {value: "从站开关"},
             // RS-485连接配置（共享配置节点）
-            serialPortConfig: {value: "", type: "serial-port-config"},
-            // MQTT配置
-            mqttServer: {value: "", type: "mqtt-server-config"},
+            serialPortConfig: {value: "", type: "serial-port-config", required: true},
+            // MQTT配置（可选）
+            mqttServer: {value: "", type: "mqtt-server-config", required: false},
             // 开关面板配置
             switchBrand: {value: "symi"},  // 品牌选择
             buttonType: {value: "switch"},  // 按钮类型：switch=开关模式，scene=场景模式
@@ -55,18 +55,22 @@
         </div>
     </div>
     
-    <!-- MQTT配置 -->
+    <!-- MQTT配置（可选） -->
     <hr style="margin: 15px 0; border: 0; border-top: 2px solid #e0e0e0;">
     <div class="form-row">
         <label style="width: 100%; margin-bottom: 8px;">
             <i class="fa fa-cloud" style="color: #9c27b0;"></i> 
             <span style="font-size: 14px; font-weight: 600; color: #333;">MQTT服务器配置</span>
+            <span style="margin-left: 8px; padding: 2px 8px; background: #e3f2fd; color: #1976d2; border-radius: 3px; font-size: 11px; font-weight: 500;">可选</span>
         </label>
+        <div style="font-size: 11px; color: #555; padding: 10px 12px; background: linear-gradient(135deg, #e3f2fd 0%, #f0f7ff 100%); border-left: 4px solid #2196f3; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.08);">
+            <strong>💡 提示：</strong>不配置MQTT则使用<strong>本地模式</strong>（纯串口通信），配置MQTT则使用<strong>MQTT模式</strong>（可接入Home Assistant等平台）
+        </div>
     </div>
     
     <div class="form-row">
         <label for="node-input-mqttServer" style="width: 110px;"><i class="fa fa-server"></i> MQTT服务器</label>
-        <input type="text" id="node-input-mqttServer" placeholder="选择或添加MQTT服务器配置" style="width: calc(70% - 110px);">
+        <input type="text" id="node-input-mqttServer" placeholder="空" style="width: calc(70% - 110px);">
         <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
             选择已配置的MQTT服务器（需与主站节点使用同一配置）
         </div>

package/nodes/modbus-slave-switch.js

@@ -309,24 +309,38 @@ module.exports = function(RED) {
             }
         };
         
-        // 发送命令到继电器（通过MQTT，由主站节点统一处理）
+        // 发送命令到继电器（支持两种模式：MQTT模式和本地模式）
         node.sendMqttCommand = function(state) {
-            if (!node.mqttClient || !node.mqttClient.connected) {
-                node.warn('MQTT未连接，无法发送命令');
+            // 模式1：MQTT模式（通过MQTT发送命令，由主站节点统一处理）
+            if (node.mqttClient && node.mqttClient.connected) {
+                // 直接发送MQTT命令（不使用队列，立即发送）
+                // 主站节点会处理去重和防抖
+                const commandTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/set`;
+                const payload = state ? 'ON' : 'OFF';
+
+                node.mqttClient.publish(commandTopic, payload, { qos: 1 }, (err) => {
+                    if (err) {
+                        node.error(`MQTT发送失败: ${err.message}`);
+                    }
+                    // 成功时不输出日志，减少总线负担
+                });
                 return;
             }
 
-            // 直接发送MQTT命令（不使用队列，立即发送）
-            // 主站节点会处理去重和防抖
-            const commandTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/set`;
-            const payload = state ? 'ON' : 'OFF';
-
-            node.mqttClient.publish(commandTopic, payload, { qos: 1 }, (err) => {
-                if (err) {
-                    node.error(`MQTT发送失败: ${err.message}`);
-                }
-                // 成功时不输出日志，减少总线负担
-            });
+            // 模式2：本地模式（通过Node-RED消息输出，直接连线到主站节点）
+            // 当MQTT未连接时，通过节点输出发送控制命令
+            const msg = {
+                payload: {
+                    cmd: "writeCoil",
+                    slave: node.config.targetSlaveAddress,
+                    coil: node.config.targetCoilNumber,
+                    value: state
+                },
+                topic: `modbus/write/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}`
+            };
+            
+            node.send(msg);
+            node.log(`本地模式：发送控制命令到从站${node.config.targetSlaveAddress} 线圈${node.config.targetCoilNumber} = ${state ? 'ON' : 'OFF'}`);
         };
         
         // 处理命令队列（防止多个按键同时按下造成冲突）
@@ -494,20 +508,40 @@ module.exports = function(RED) {
         // 更新节点状态显示
         node.updateStatus = function() {
             const rs485Status = node.isRs485Connected ? 'OK' : 'ERR';
-            const mqttStatus = node.mqttClient && node.mqttClient.connected ? 'OK' : 'ERR';
             const state = node.currentState ? 'ON' : 'OFF';
-            
-            if (node.isRs485Connected && node.mqttClient && node.mqttClient.connected) {
-                node.status({
-                    fill: node.currentState ? "green" : "grey",
-                    shape: "dot",
-                    text: `RS485-${rs485Status} MQTT-${mqttStatus} ${state}`
-                });
+            const hasMqttConfig = node.config.mqttBroker && node.config.mqttBroker.trim() !== '';
+            const mqttConnected = node.mqttClient && node.mqttClient.connected;
+            
+            // RS485连接正常
+            if (node.isRs485Connected) {
+                if (!hasMqttConfig) {
+                    // 本地模式（未配置MQTT）
+                    node.status({
+                        fill: node.currentState ? "green" : "blue",
+                        shape: "dot",
+                        text: `本地模式 RS485-${rs485Status} ${state}`
+                    });
+                } else if (mqttConnected) {
+                    // MQTT模式（已配置且已连接）
+                    node.status({
+                        fill: node.currentState ? "green" : "grey",
+                        shape: "dot",
+                        text: `MQTT模式 ${state}`
+                    });
+                } else {
+                    // MQTT配置但未连接（使用本地模式）
+                    node.status({
+                        fill: node.currentState ? "green" : "blue",
+                        shape: "ring",
+                        text: `本地模式(MQTT断开) ${state}`
+                    });
+                }
             } else {
+                // RS485连接失败
                 node.status({
                     fill: "red",
                     shape: "ring",
-                    text: `RS485-${rs485Status} MQTT-${mqttStatus}`
+                    text: `RS485连接失败`
                 });
             }
         };
@@ -516,7 +550,8 @@ module.exports = function(RED) {
         node.connectMqtt = function() {
             // 验证MQTT broker配置
             if (!node.config.mqttBroker || node.config.mqttBroker.trim() === '') {
-                node.warn('MQTT broker地址未配置，跳过MQTT连接');
+                node.log('MQTT未配置 - 使用本地模式（通过Node-RED连线控制）');
+                node.log('提示：将此节点连线到主站节点，即可实现本地控制');
                 return;
             }
             

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,7 +1,7 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.6.1",
-  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、智能MQTT连接（自动fallback HassOS/Docker环境）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
+  "version": "2.6.3",
+  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"