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

package/nodes/modbus-slave-switch.js

@@ -1,8 +1,6 @@
 module.exports = function(RED) {
     "use strict";
     const mqtt = require("mqtt");
-    const ModbusRTU = require("modbus-serial");
-    const net = require("net");
     const protocol = require("./lightweight-protocol");
     
     // 串口列表API - 支持Windows、Linux、macOS所有串口设备
@@ -60,52 +58,61 @@ module.exports = function(RED) {
     function ModbusSlaveSwitchNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        
+
+        // 获取RS-485连接配置节点
+        node.serialPortConfig = RED.nodes.getNode(config.serialPortConfig);
+        if (!node.serialPortConfig) {
+            node.error('未配置RS-485连接，请在节点配置中选择连接配置');
+            node.status({fill: "red", shape: "ring", text: "未配置连接"});
+            return;
+        }
+
         // 获取MQTT服务器配置节点
         node.mqttServerConfig = RED.nodes.getNode(config.mqttServer);
-        
+
         // 配置参数
         node.config = {
-            // RS-485总线连接配置
-            connectionType: config.connectionType,
-            tcpHost: config.tcpHost,
-            tcpPort: parseInt(config.tcpPort),
-            serialPort: config.serialPort,
-            serialBaudRate: parseInt(config.serialBaudRate),
-            serialDataBits: parseInt(config.serialDataBits),
-            serialStopBits: parseInt(config.serialStopBits),
-            serialParity: config.serialParity,
-            // 从config节点读取MQTT配置
+            // 从MQTT配置节点读取MQTT配置
             mqttBroker: node.mqttServerConfig ? node.mqttServerConfig.broker : "mqtt://localhost:1883",
             mqttUsername: node.mqttServerConfig ? node.mqttServerConfig.username : "",
             mqttPassword: node.mqttServerConfig ? (node.mqttServerConfig.credentials ? node.mqttServerConfig.credentials.password : "") : "",
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay",
+            // 开关面板配置
             switchBrand: config.switchBrand || "symi",         // 面板品牌（默认亖米）
             switchId: parseInt(config.switchId) || 0,           // 开关ID（0-255，物理面板地址）
             buttonNumber: parseInt(config.buttonNumber) || 1,  // 按钮编号（1-8）
             targetSlaveAddress: parseInt(config.targetSlaveAddress) || 10,  // 目标继电器从站地址
             targetCoilNumber: parseInt(config.targetCoilNumber) || 0        // 目标继电器线圈编号
         };
-        
+
         node.currentState = false;
         node.mqttClient = null;
-        node.rs485Client = new ModbusRTU();  // RS-485总线客户端
-        node.isRs485Connected = false;
-        node.reconnectTimer = null;
         node.isClosing = false;
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
-        
-        // TCP帧缓冲区（用于处理分包和粘包）
-        node.frameBuffer = Buffer.alloc(0);
-        
-        // 命令队列（处理多个按键同时按下）
+
+        // 命令队列（处理多个按键同时按下）- 带时间戳
         node.commandQueue = [];
         node.isProcessingCommand = false;
-        
-        // 指示灯反馈队列（40ms间隔发送）
+
+        // 指示灯反馈队列（40ms间隔发送）- 带时间戳
         node.ledFeedbackQueue = [];
         node.isProcessingLedFeedback = false;
+
+        // 队列超时时间（3秒）
+        node.queueTimeout = 3000;
+
+        // 防死循环：记录最后一次状态变化的时间戳和值
+        node.lastStateChange = {
+            timestamp: 0,
+            value: false
+        };
+
+        // 节点初始化标志（用于静默初始化期间的警告）
+        node.isInitializing = true;
+
+        // 节点关闭标志（用于静默关闭期间的警告）
+        node.isClosing = false;
         
         // MQTT主题（映射到继电器设备）
         node.stateTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/state`;
@@ -188,184 +195,110 @@ module.exports = function(RED) {
         // 连接RS-485总线（物理开关面板）
         node.connectRs485 = async function() {
             try {
-                if (node.config.connectionType === "tcp") {
-                    // TCP连接验证
-                    if (!node.config.tcpHost) {
-                        throw new Error("TCP主机地址未配置");
-                    }
-                    await node.rs485Client.connectTCP(node.config.tcpHost, {
-                        port: node.config.tcpPort
-                    });
-                    node.log(`RS485连接成功（TCP）: ${node.config.tcpHost}:${node.config.tcpPort}`);
-                    node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
-                } else {
-                    // 串口连接验证
-                    if (!node.config.serialPort) {
-                        throw new Error("串口未配置，请配置串口路径（如：COM1、/dev/ttyUSB0、/dev/ttyS1）");
-                    }
-                    await node.rs485Client.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(`RS485连接成功（串口）: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);
-                    node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
-                }
-                
-                node.rs485Client.setTimeout(5000);
+                // 使用共享连接配置（由配置节点管理）
+                node.log(`使用共享RS-485连接配置: ${node.serialPortConfig.connectionType === 'tcp' ?
+                    `TCP ${node.serialPortConfig.tcpHost}:${node.serialPortConfig.tcpPort}` :
+                    `串口 ${node.serialPortConfig.serialPort} @ ${node.serialPortConfig.baudRate}bps`}`);
+                node.log(`监听Symi开关${node.config.switchId}的按钮${node.config.buttonNumber}按键事件...`);
+
                 node.isRs485Connected = true;
                 node.updateStatus();
-                
+
+                // 结束初始化阶段（5秒后）- 避免部署时大量LED反馈同时发送
+                setTimeout(() => {
+                    node.isInitializing = false;
+                    // 初始化完成后，处理积累的LED反馈队列
+                    node.processLedFeedbackQueue();
+                }, 5000);
+
                 // 监听物理开关面板的按键事件
                 node.startListeningButtonEvents();
-                
+
             } catch (err) {
                 node.error(`RS-485连接失败: ${err.message}`);
                 node.isRs485Connected = false;
                 node.updateStatus();
-                
-                // 5秒后重试连接（仅在配置有效时）
-                if (!node.isClosing && !node.reconnectTimer) {
-                    // 如果是配置错误，不重试
-                    if (err.message.includes("未配置")) {
-                        node.warn("RS-485连接配置无效，请检查配置");
-                        return;
-                    }
-                    node.reconnectTimer = setTimeout(() => {
-                        node.reconnectTimer = null;
-                        node.connectRs485();
-                    }, 5000);
-                }
             }
         };
         
         // 监听物理开关面板的按键事件
         node.startListeningButtonEvents = function() {
             node.log(`开始监听开关面板 ${node.config.switchId} 的按钮 ${node.config.buttonNumber}`);
-            
-            // 监听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) => {
-                        node.handleTcpData(data);
-                    });
-                    node.log('TCP数据监听已启动（使用帧缓冲区）');
-                }
+
+            // 使用共享连接配置的数据监听器
+            if (node.serialPortConfig) {
+                // 定义数据监听器函数
+                node.serialDataListener = (data) => {
+                    node.log(`RS-485收到 ${data.length} 字节: ${data.toString('hex').toUpperCase()}`);
+                    node.handleRs485Data(data);
+                };
+
+                // 注册到共享连接配置
+                node.serialPortConfig.registerDataListener(node.serialDataListener);
+
+                node.log('RS-485数据监听已启动（共享连接）');
             } else {
-                // 串口模式：监听串口数据（串口通常自动处理帧边界）
-                if (node.rs485Client._port) {
-                    node.rs485Client._port.on('data', (data) => {
-                        node.handleRs485Data(data);
-                    });
-                    node.log('串口数据监听已启动');
-                }
-            }
-        };
-        
-        // 处理TCP流式数据（需要缓冲和帧边界检测）
-        node.handleTcpData = function(data) {
-            try {
-                // 将接收到的数据追加到缓冲区
-                node.frameBuffer = Buffer.concat([node.frameBuffer, data]);
-                
-                // 输出缓冲区状态
-                node.log(`TCP收到 ${data.length} 字节，缓冲区共 ${node.frameBuffer.length} 字节`);
-                
-                // 从缓冲区提取完整的帧
-                while (node.frameBuffer.length > 0) {
-                    // 查找帧头 0x7E
-                    const startIdx = node.frameBuffer.indexOf(0x7E);
-                    
-                    if (startIdx === -1) {
-                        // 没有找到帧头，清空缓冲区
-                        node.frameBuffer = Buffer.alloc(0);
-                        break;
-                    }
-                    
-                    if (startIdx > 0) {
-                        // 丢弃帧头之前的无效数据
-                        node.frameBuffer = node.frameBuffer.slice(startIdx);
-                    }
-                    
-                    // 查找帧尾 0x7D
-                    const endIdx = node.frameBuffer.indexOf(0x7D, 1);
-                    
-                    if (endIdx === -1) {
-                        // 没有找到帧尾，等待更多数据
-                        if (node.frameBuffer.length > 100) {
-                            // 缓冲区过大，可能是错误数据，清空
-                            node.warn('缓冲区过大，清空');
-                            node.frameBuffer = Buffer.alloc(0);
-                        }
-                        break;
-                    }
-                    
-                    // 提取完整的帧（包括帧头和帧尾）
-                    const frame = node.frameBuffer.slice(0, endIdx + 1);
-                    
-                    // 从缓冲区移除已处理的帧
-                    node.frameBuffer = node.frameBuffer.slice(endIdx + 1);
-                    
-                    // 处理这一帧
-                    node.handleRs485Data(frame);
-                }
-            } catch (err) {
-                node.error(`TCP数据处理错误: ${err.message}`);
-                node.frameBuffer = Buffer.alloc(0);  // 错误时清空缓冲区
+                node.error('RS-485连接配置未初始化，无法监听数据');
             }
         };
-        
+
         // 处理RS-485接收到的数据
         node.handleRs485Data = function(data) {
             try {
                 // 输出原始数据（十六进制）- 方便调试
                 const hexData = Array.from(data).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
                 node.log(`RS485收到数据: ${hexData}`);
-                
+
                 // 解析轻量级协议帧
                 const frame = protocol.parseFrame(data);
                 if (!frame) {
                     node.warn(`无效的协议帧（CRC校验失败或格式错误）: ${hexData}`);
                     return;
                 }
-                
+
                 node.log(`解析成功: 设备地址=${frame.deviceAddr} 通道=${frame.channel} 数据类型=0x${frame.dataType.toString(16).toUpperCase()} 操作码=0x${frame.opCode.toString(16).toUpperCase()}`);
-                
+
+                // 忽略 REPORT (0x04) 类型的帧（这是面板对我们指令的确认，不是按键事件）
+                // 只处理 SET (0x03) 类型的帧（真正的按键事件）
+                if (frame.dataType === 0x04) {
+                    node.log(`忽略 REPORT 帧（面板确认收到指令）`);
+                    return;
+                }
+
                 // 检测是否是按键按下事件
                 const buttonEvent = protocol.detectButtonPress(frame);
                 if (!buttonEvent) {
                     node.log(`不是按键事件（设备类型=${frame.deviceType} 数据类型=${frame.dataType} 操作码=${frame.opCode}）`);
                     return;
                 }
-                
-                node.log(`检测到按键事件: 类型=${buttonEvent.type} 设备=${buttonEvent.deviceAddr} 通道=${buttonEvent.channel}`);
-                
-                // 检查是否是我们监听的开关和按钮
-                if (buttonEvent.deviceAddr === node.config.switchId) {
+
+                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;
+
+                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}`);
@@ -373,19 +306,27 @@ module.exports = function(RED) {
             }
         };
         
-        // 发送MQTT命令到继电器（入队）
+        // 发送命令到继电器（通过MQTT，由主站节点统一处理）
         node.sendMqttCommand = function(state) {
             if (!node.mqttClient || !node.mqttClient.connected) {
                 node.warn('MQTT未连接，无法发送命令');
                 return;
             }
-            
-            // 加入命令队列
-            node.commandQueue.push(state);
-            node.log(`MQTT命令已入队，队列长度: ${node.commandQueue.length}`);
-            
-            // 启动队列处理
-            node.processCommandQueue();
+
+            // 直接发送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}`);
+                } else {
+                    node.log(`MQTT命令已发送: ${payload} → ${commandTopic}`);
+                    // 不立即发送LED反馈，等待MQTT状态消息确认后再发送
+                    // 这样可以确保继电器真的动作了，避免重复发送
+                }
+            });
         };
         
         // 处理命令队列（防止多个按键同时按下造成冲突）
@@ -396,8 +337,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 {
@@ -429,57 +382,97 @@ module.exports = function(RED) {
         
         // 发送控制指令到物理开关面板（控制指示灯等）- 入队
         node.sendCommandToPanel = function(state) {
-            if (!node.isRs485Connected) {
-                node.warn('RS-485未连接，无法发送指示灯反馈');
+            // 检查连接状态
+            if (!node.serialPortConfig || !node.serialPortConfig.connection) {
+                // 初始化期间静默警告
+                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;
+
+                    // 使用轻量级协议构建LED反馈指令（REPORT类型）
+                    // 协议规定：面板发送0x03(SET)按键事件，主机应该用0x04(REPORT)反馈LED状态
+                    // 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'}`);
-                        }
+
+                    // 发送到RS-485总线（使用共享连接配置）
+                    if (node.serialPortConfig) {
+                        node.serialPortConfig.write(command, (err) => {
+                            if (err) {
+                                node.error(`LED反馈发送失败: ${err.message}`);
+                            } else {
+                                const hexCmd = Array.from(command).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
+                                const connType = node.serialPortConfig.connectionType === 'tcp' ? 'TCP' : '串口';
+                                node.log(`LED反馈已发送(${connType}/REPORT): 面板${node.config.switchId} 按键${node.config.buttonNumber} ${state ? 'ON' : 'OFF'} [${hexCmd}]`);
+                            }
+                        });
                     } else {
-                        // 串口模式
-                        if (node.rs485Client._port) {
-                            node.rs485Client._port.write(command);
-                            node.log(`LED反馈已发送(串口): 开关${node.config.switchId} 按钮${node.config.buttonNumber} ${state ? 'ON' : 'OFF'}`);
-                        }
+                        node.warn('RS-485连接未配置，无法发送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}`);
@@ -537,9 +530,7 @@ module.exports = function(RED) {
             if (node.config.mqttUsername) {
                 options.username = node.config.mqttUsername;
                 options.password = node.config.mqttPassword;
-                node.log(`MQTT认证: 用户名=${node.config.mqttUsername}, 密码已设置=${!!node.config.mqttPassword}`);
-            } else {
-                node.warn('MQTT未配置认证信息，如果broker需要认证将会连接失败');
+                node.log(`MQTT认证: 用户名=${node.config.mqttUsername}`);
             }
             
             // 尝试连接函数
@@ -558,6 +549,7 @@ module.exports = function(RED) {
                     lastConnectAttempt = Date.now();
                     
                     node.mqttClient.on('connect', () => {
+                        node.mqttConnected = true;
                         node.log(`MQTT已连接: ${brokerUrl}`);
                         
                         // 成功连接后，更新配置的broker地址（下次优先使用成功的地址）
@@ -670,13 +662,29 @@ module.exports = function(RED) {
                     node.mqttClient.on('message', (topic, message) => {
                         if (topic === node.stateTopic) {
                             const state = message.toString();
-                            node.currentState = (state === 'ON' || state === 'true' || state === '1');
-                            
+                            const newState = (state === 'ON' || state === 'true' || state === '1');
+
+                            // 防死循环：如果状态在100ms内没有变化，跳过LED反馈
+                            const now = Date.now();
+                            const timeSinceLastChange = now - node.lastStateChange.timestamp;
+                            const stateChanged = (newState !== node.lastStateChange.value);
+
+                            if (!stateChanged && timeSinceLastChange < 100) {
+                                // 状态未变化且时间间隔太短，跳过LED反馈（避免死循环）
+                                node.log(`跳过LED反馈（状态未变化，间隔${timeSinceLastChange}ms）`);
+                                return;
+                            }
+
+                            // 更新状态
+                            node.currentState = newState;
+                            node.lastStateChange.timestamp = now;
+                            node.lastStateChange.value = newState;
+
                             node.updateStatus();
-                            
+
                             // 发送控制指令到物理开关面板（同步指示灯等）
                             node.sendCommandToPanel(node.currentState);
-                            
+
                             // 输出状态
                             node.send({
                                 payload: node.currentState,
@@ -751,23 +759,46 @@ module.exports = function(RED) {
                 node.reconnectTimer = null;
             }
             
-            // 关闭RS-485连接
-            if (node.rs485Client && node.isRs485Connected) {
+            // 清理队列（释放内存）
+            node.commandQueue = [];
+            node.ledFeedbackQueue = [];
+            node.frameBuffer = Buffer.alloc(0);
+            
+            // 注销RS-485数据监听器（不关闭连接，由配置节点管理）
+            if (node.serialPortConfig && node.serialDataListener) {
                 try {
-                    node.rs485Client.close(() => {
-                        node.log('RS-485连接已关闭');
-                    });
+                    node.serialPortConfig.unregisterDataListener(node.serialDataListener);
+                    node.log('RS-485数据监听器已注销');
                 } catch (err) {
-                    node.warn(`关闭RS-485连接时出错: ${err.message}`);
+                    node.warn(`注销RS-485监听器时出错: ${err.message}`);
                 }
+                node.serialDataListener = null;
             }
             
             // 关闭MQTT连接
-            if (node.mqttClient && node.mqttClient.connected) {
-                node.mqttClient.end(false, () => {
-                    node.log('MQTT连接已关闭');
+            if (node.mqttClient) {
+                try {
+                    if (node.mqttClient.connected) {
+                        // 移除所有监听器（防止内存泄漏）
+                        node.mqttClient.removeAllListeners();
+                        node.mqttClient.end(false, () => {
+                            node.log('MQTT连接已关闭');
+                            node.mqttClient = null;
+                            node.mqttConnected = false;
+                            done();
+                        });
+                    } else {
+                        node.mqttClient.removeAllListeners();
+                        node.mqttClient = null;
+                        node.mqttConnected = false;
+                        done();
+                    }
+                } catch (err) {
+                    node.warn(`关闭MQTT连接时出错: ${err.message}`);
+                    node.mqttClient = null;
+                    node.mqttConnected = false;
                     done();
-                });
+                }
             } else {
                 done();
             }