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

package/README.md

@@ -507,83 +507,18 @@ docker run --privileged ...
 - **容错能力**：Modbus从站离线不影响其他从站，MQTT断线自动重连
 
 
-> **最新版本 v2.5.0** - Mac串口兼容性修复，互斥锁优化，确保各平台稳定运行
-
-## 版本更新
-
-### v2.5.0 (2025-10-20) - Mac串口兼容性与互斥锁优化
-
-**核心修复**：
-- 修复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总线 → 指示灯同步
-```
-
-**测试验证**：
-- TCP网关（192.168.2.110:1031）连接正常
-- 帧缓冲区正确处理分包数据
-- 多个按键同时按下不丢失
-- LED指示灯同步稳定
-- 适合Linux工控机24/7长期稳定运行
-
----
+## 版本信息
+
+**当前版本**: v2.5.2
+
+**主要特性**：
+- Modbus TCP/RTU协议完整支持
+- MQTT自动发现与Home Assistant集成
+- 物理开关面板双向同步（Symi轻量级协议）
+- TCP帧缓冲与命令队列机制
+- 多设备并发控制互斥锁
+- 智能MQTT连接fallback
+- 适合Linux工控机长期稳定运行
 
 **升级方式**：
 ```bash

package/nodes/lightweight-protocol.js

@@ -62,7 +62,7 @@ module.exports = {
     },
     
     /**
-     * 构建单灯控制指令
+     * 构建单灯控制指令（SET类型，用于主动控制）
      * @param {number} localAddr - 本机地址（发送方）
      * @param {number} deviceAddr - 设备地址
      * @param {number} channel - 通道号（1-8）
@@ -95,6 +95,40 @@ module.exports = {
         return buffer;
     },
     
+    /**
+     * 构建单灯状态反馈指令（REPORT类型，用于状态同步到面板指示灯）
+     * @param {number} localAddr - 本机地址（发送方）
+     * @param {number} deviceAddr - 设备地址
+     * @param {number} channel - 通道号（1-8）
+     * @param {boolean} state - 灯状态（true=开，false=关）
+     * @returns {Buffer} 完整的指令帧
+     */
+    buildSingleLightReport: function(localAddr, deviceAddr, channel, state) {
+        const buffer = Buffer.alloc(15);
+        let idx = 0;
+        
+        buffer[idx++] = this.FRAME_HEADER;      // 帧头 0x7E
+        buffer[idx++] = localAddr;              // 本机地址
+        buffer[idx++] = this.DATA_TYPE_REPORT;  // 数据类型：上报（关键！）
+        buffer[idx++] = 0x0F;                   // 数据长度
+        buffer[idx++] = this.DEVICE_TYPE_LIGHT; // 设备类型：灯光
+        buffer[idx++] = 0x00;                   // 品牌ID
+        buffer[idx++] = deviceAddr;             // 设备地址
+        buffer[idx++] = channel;                // 设备通道
+        buffer[idx++] = 0x00;                   // 房间号
+        buffer[idx++] = 0x00;                   // 房间类型
+        buffer[idx++] = 0x00;                   // 房间ID
+        buffer[idx++] = this.LIGHT_OP_SINGLE;   // 操作码：单灯控制
+        buffer[idx++] = state ? 0x01 : 0x00;    // 操作信息：1开0关
+        
+        // 计算CRC8校验（从帧头到操作信息）
+        const crc = this.calculateCRC8(buffer, 15);
+        buffer[idx++] = crc;                    // CRC8校验
+        buffer[idx++] = this.FRAME_TAIL;        // 报尾 0x7D
+        
+        return buffer;
+    },
+    
     /**
      * 构建多灯控制指令
      * @param {number} localAddr - 本机地址

package/nodes/modbus-master.js

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

package/nodes/modbus-slave-switch.js

@@ -89,7 +89,8 @@ module.exports = function(RED) {
         
         node.currentState = false;
         node.mqttClient = null;
-        node.rs485Client = new ModbusRTU();  // RS-485总线客户端
+        node.rs485Client = new ModbusRTU();  // RS-485总线客户端（仅串口模式使用）
+        node.tcpSocket = null;  // TCP Socket（TCP模式使用）
         node.isRs485Connected = false;
         node.reconnectTimer = null;
         node.isClosing = false;
@@ -99,14 +100,23 @@ module.exports = function(RED) {
         // TCP帧缓冲区（用于处理分包和粘包）
         node.frameBuffer = Buffer.alloc(0);
         
-        // 命令队列（处理多个按键同时按下）
+        // 命令队列（处理多个按键同时按下）- 带时间戳
         node.commandQueue = [];
         node.isProcessingCommand = false;
         
-        // 指示灯反馈队列（40ms间隔发送）
+        // 指示灯反馈队列（40ms间隔发送）- 带时间戳
         node.ledFeedbackQueue = [];
         node.isProcessingLedFeedback = false;
         
+        // 队列超时时间（3秒）
+        node.queueTimeout = 3000;
+        
+        // 节点初始化标志（用于静默初始化期间的警告）
+        node.isInitializing = true;
+        
+        // 节点关闭标志（用于静默关闭期间的警告）
+        node.isClosing = 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`;
@@ -193,11 +203,35 @@ module.exports = function(RED) {
                     if (!node.config.tcpHost) {
                         throw new Error("TCP主机地址未配置");
                     }
-                    await node.rs485Client.connectTCP(node.config.tcpHost, {
-                        port: node.config.tcpPort
+                    
+                    // 使用net.Socket直接连接（不使用modbus-serial，因为需要监听原始数据）
+                    node.tcpSocket = new net.Socket();
+                    
+                    // 设置TCP选项
+                    node.tcpSocket.setKeepAlive(true, 60000);
+                    node.tcpSocket.setNoDelay(true);
+                    
+                    // 连接TCP
+                    await new Promise((resolve, reject) => {
+                        const timeout = setTimeout(() => {
+                            node.tcpSocket.destroy();
+                            reject(new Error('TCP连接超时'));
+                        }, 5000);
+                        
+                        node.tcpSocket.connect(node.config.tcpPort, node.config.tcpHost, () => {
+                            clearTimeout(timeout);
+                            resolve();
+                        });
+                        
+                        node.tcpSocket.on('error', (err) => {
+                            clearTimeout(timeout);
+                            reject(err);
+                        });
                     });
+                    
                     node.log(`RS485连接成功（TCP）: ${node.config.tcpHost}:${node.config.tcpPort}`);
                     node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
+                    
                 } else {
                     // 串口连接验证
                     if (!node.config.serialPort) {
@@ -213,10 +247,16 @@ module.exports = function(RED) {
                     node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
                 }
                 
-                node.rs485Client.setTimeout(5000);
                 node.isRs485Connected = true;
                 node.updateStatus();
                 
+                // 结束初始化阶段（5秒后）- 避免部署时大量LED反馈同时发送
+                setTimeout(() => {
+                    node.isInitializing = false;
+                    // 初始化完成后，处理积累的LED反馈队列
+                    node.processLedFeedbackQueue();
+                }, 5000);
+                
                 // 监听物理开关面板的按键事件
                 node.startListeningButtonEvents();
                 
@@ -225,6 +265,12 @@ module.exports = function(RED) {
                 node.isRs485Connected = false;
                 node.updateStatus();
                 
+                // 清理连接
+                if (node.tcpSocket) {
+                    node.tcpSocket.destroy();
+                    node.tcpSocket = null;
+                }
+                
                 // 5秒后重试连接（仅在配置有效时）
                 if (!node.isClosing && !node.reconnectTimer) {
                     // 如果是配置错误，不重试
@@ -247,12 +293,42 @@ module.exports = function(RED) {
             // 监听RS-485数据
             if (node.config.connectionType === "tcp") {
                 // TCP模式：监听socket数据（需要处理帧边界）
-                if (node.rs485Client._port && node.rs485Client._port.socket) {
-                    const socket = node.rs485Client._port.socket;
-                    socket.on('data', (data) => {
+                if (node.tcpSocket) {
+                    node.tcpSocket.on('data', (data) => {
                         node.handleTcpData(data);
                     });
+                    
+                    // 监听连接关闭事件
+                    node.tcpSocket.on('close', () => {
+                        // 部署或初始化期间静默警告
+                        if (!node.isClosing && !node.isInitializing) {
+                            node.warn('TCP连接已关闭');
+                        }
+                        node.isRs485Connected = false;
+                        node.updateStatus();
+                        
+                        // 尝试重连
+                        if (!node.isClosing && !node.reconnectTimer) {
+                            node.reconnectTimer = setTimeout(() => {
+                                node.reconnectTimer = null;
+                                node.connectRs485();
+                            }, 5000);
+                        }
+                    });
+                    
+                    // 监听连接错误事件（限制错误日志频率）
+                    node.tcpSocket.on('error', (err) => {
+                        const now = Date.now();
+                        // 只在10分钟内记录一次错误日志（避免刷屏）
+                        if (now - node.lastMqttErrorLog > node.errorLogInterval) {
+                            node.error(`TCP连接错误: ${err.message}`);
+                            node.lastMqttErrorLog = now;
+                        }
+                    });
+                    
                     node.log('TCP数据监听已启动（使用帧缓冲区）');
+                } else {
+                    node.error('TCP socket未初始化，无法监听数据');
                 }
             } else {
                 // 串口模式：监听串口数据（串口通常自动处理帧边界）
@@ -261,6 +337,8 @@ module.exports = function(RED) {
                         node.handleRs485Data(data);
                     });
                     node.log('串口数据监听已启动');
+                } else {
+                    node.error('串口未初始化，无法监听数据');
                 }
             }
         };
@@ -341,31 +419,33 @@ module.exports = function(RED) {
                     return;
                 }
                 
-                node.log(`检测到按键事件: 类型=${buttonEvent.type} 设备=${buttonEvent.deviceAddr} 通道=${buttonEvent.channel}`);
+                node.log(`检测到按键事件: 类型=${buttonEvent.type} 本地地址=${buttonEvent.raw.localAddr} 设备=${buttonEvent.deviceAddr} 通道=${buttonEvent.channel}`);
+                
+                // 计算实际按键编号（Symi协议公式）
+                // 例如：devAddr=1,channel=1→按键1；devAddr=2,channel=1→按键5
+                const actualButtonNumber = buttonEvent.deviceAddr * 4 - 4 + buttonEvent.channel;
                 
-                // 检查是否是我们监听的开关和按钮
-                if (buttonEvent.deviceAddr === node.config.switchId) {
+                node.log(`实际按键编号: ${actualButtonNumber}（设备${buttonEvent.deviceAddr} × 4 - 4 + 通道${buttonEvent.channel}）`);
+                
+                // 检查是否是我们监听的开关面板和按钮
+                // switchId对应本地地址（物理面板地址）
+                // buttonNumber对应实际按键编号（1-8）
+                if (buttonEvent.raw.localAddr === node.config.switchId && actualButtonNumber === node.config.buttonNumber) {
                     if (buttonEvent.type === 'single') {
-                        // 单键按下
-                        if (buttonEvent.channel === node.config.buttonNumber) {
-                            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}`);
-                        }
+                        node.log(`匹配成功！面板${node.config.switchId} 按键${node.config.buttonNumber} 状态=${buttonEvent.state ? 'ON' : 'OFF'}`);
+                        // 发送MQTT命令到继电器
+                        node.sendMqttCommand(buttonEvent.state);
                     } 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 ? 'ON' : 'OFF'}`);
-                            // 发送MQTT命令到继电器
-                            node.sendMqttCommand(state);
-                        }
+                        node.log(`匹配成功！面板${node.config.switchId} 多键按钮${node.config.buttonNumber} 状态=${buttonEvent.state ? 'ON' : 'OFF'}`);
+                        // 发送MQTT命令到继电器
+                        node.sendMqttCommand(buttonEvent.state);
                     }
                 } else {
-                    node.log(`开关ID不匹配: 收到${buttonEvent.deviceAddr} 期望${node.config.switchId}`);
+                    if (buttonEvent.raw.localAddr !== node.config.switchId) {
+                        node.log(`面板地址不匹配: 收到${buttonEvent.raw.localAddr} 期望${node.config.switchId}`);
+                    } else {
+                        node.log(`按键编号不匹配: 收到${actualButtonNumber} 期望${node.config.buttonNumber}`);
+                    }
                 }
             } catch (err) {
                 node.error(`解析RS-485数据失败: ${err.message}`);
@@ -380,8 +460,12 @@ module.exports = function(RED) {
                 return;
             }
             
-            // 加入命令队列
-            node.commandQueue.push(state);
+            // 清理过期队列项（超过2秒）
+            const now = Date.now();
+            node.commandQueue = node.commandQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
+            
+            // 加入命令队列（带时间戳）
+            node.commandQueue.push({ state, timestamp: now });
             node.log(`MQTT命令已入队，队列长度: ${node.commandQueue.length}`);
             
             // 启动队列处理
@@ -396,8 +480,20 @@ module.exports = function(RED) {
             
             node.isProcessingCommand = true;
             
+            // 清理过期队列项
+            const now = Date.now();
+            node.commandQueue = node.commandQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
+            
             while (node.commandQueue.length > 0) {
-                const state = node.commandQueue.shift();
+                const item = node.commandQueue.shift();
+                
+                // 再次检查是否过期
+                if (Date.now() - item.timestamp >= node.queueTimeout) {
+                    node.warn(`丢弃过期命令（${Date.now() - item.timestamp}ms）`);
+                    continue;
+                }
+                
+                const state = item.state;
                 const command = state ? 'ON' : 'OFF';
                 
                 try {
@@ -430,56 +526,99 @@ module.exports = function(RED) {
         // 发送控制指令到物理开关面板（控制指示灯等）- 入队
         node.sendCommandToPanel = function(state) {
             if (!node.isRs485Connected) {
-                node.warn('RS-485未连接，无法发送指示灯反馈');
+                // 初始化期间静默警告
+                if (!node.isInitializing) {
+                    node.warn('RS-485未连接，无法发送指示灯反馈');
+                }
                 return;
             }
             
-            // 加入LED反馈队列
-            node.ledFeedbackQueue.push(state);
+            // 清理过期队列项（超过3秒）
+            const now = Date.now();
+            node.ledFeedbackQueue = node.ledFeedbackQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
+            
+            // 加入LED反馈队列（带时间戳）
+            node.ledFeedbackQueue.push({ state, timestamp: now });
             
             // 启动队列处理
             node.processLedFeedbackQueue();
         };
         
-        // 处理LED反馈队列（40ms间隔发送）
+        // 处理LED反馈队列（基于面板ID的固定延迟）
         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);
+            
+            // 基于面板ID的固定延迟，避免多个节点同时写入TCP冲突
+            // 面板1=100ms, 面板2=200ms, 面板3=300ms, 面板4=400ms...
+            // 这样不同面板的LED反馈永远不会同时发送
+            const fixedDelay = node.config.switchId * 100;
+            if (fixedDelay > 0) {
+                await new Promise(resolve => setTimeout(resolve, fixedDelay));
+            }
+            
             while (node.ledFeedbackQueue.length > 0) {
-                const state = node.ledFeedbackQueue.shift();
+                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 {
-                    // 使用轻量级协议构建单灯控制指令
-                    // localAddr=0x01（本机），deviceAddr=开关ID，channel=按钮编号，state=开关状态
-                    const command = protocol.buildSingleLightCommand(
-                        0x01,  // 本机地址（网关地址）
-                        node.config.switchId,
-                        node.config.buttonNumber,
+                    // 根据按键编号反推设备地址和通道（Symi协议）
+                    // 例如：按键1→devAddr=1,channel=1；按键5→devAddr=2,channel=1
+                    const deviceAddr = Math.floor((node.config.buttonNumber - 1) / 4) + 1;
+                    const channel = ((node.config.buttonNumber - 1) % 4) + 1;
+                    
+                    // 使用轻量级协议构建状态反馈指令（REPORT类型，用于同步指示灯）
+                    // localAddr=面板地址，deviceAddr和channel根据按键编号计算
+                    const command = protocol.buildSingleLightReport(
+                        node.config.switchId,  // 本地地址（面板地址）
+                        deviceAddr,            // 设备地址（根据按键编号计算）
+                        channel,               // 通道（根据按键编号计算）
                         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'}`);
+                        if (node.tcpSocket && !node.tcpSocket.destroyed) {
+                            node.tcpSocket.write(command);
+                            const hexCmd = Array.from(command).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
+                            node.log(`LED反馈已发送(TCP/REPORT): 面板${node.config.switchId} 按键${node.config.buttonNumber} ${state ? 'ON' : 'OFF'} [${hexCmd}]`);
+                        } else {
+                            node.warn('TCP socket未连接，无法发送LED反馈');
                         }
                     } else {
                         // 串口模式
                         if (node.rs485Client._port) {
                             node.rs485Client._port.write(command);
-                            node.log(`LED反馈已发送(串口): 开关${node.config.switchId} 按钮${node.config.buttonNumber} ${state ? 'ON' : 'OFF'}`);
+                            const hexCmd = Array.from(command).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
+                            node.log(`LED反馈已发送(串口/REPORT): 面板${node.config.switchId} 按键${node.config.buttonNumber} ${state ? 'ON' : 'OFF'} [${hexCmd}]`);
+                        } else {
+                            node.warn('串口未连接，无法发送LED反馈');
                         }
                     }
                     
-                    // 队列间隔40ms
+                    // 队列间隔100ms（确保RS-485总线有足够时间处理）
                     if (node.ledFeedbackQueue.length > 0) {
-                        await new Promise(resolve => setTimeout(resolve, 40));
+                        await new Promise(resolve => setTimeout(resolve, 100));
                     }
                 } catch (err) {
                     node.error(`发送LED反馈失败: ${err.message}`);
@@ -751,8 +890,19 @@ module.exports = function(RED) {
                 node.reconnectTimer = null;
             }
             
-            // 关闭RS-485连接
-            if (node.rs485Client && node.isRs485Connected) {
+            // 关闭TCP连接
+            if (node.tcpSocket && !node.tcpSocket.destroyed) {
+                try {
+                    node.tcpSocket.destroy();
+                    node.log('TCP连接已关闭');
+                } catch (err) {
+                    node.warn(`关闭TCP连接时出错: ${err.message}`);
+                }
+                node.tcpSocket = null;
+            }
+            
+            // 关闭串口RS-485连接
+            if (node.rs485Client && node.isRs485Connected && node.config.connectionType !== "tcp") {
                 try {
                     node.rs485Client.close(() => {
                         node.log('RS-485连接已关闭');

package/package.json

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