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

package/nodes/modbus-slave-switch.js

@@ -1,9 +1,10 @@
 module.exports = function(RED) {
     "use strict";
     const mqtt = require("mqtt");
-    const ModbusRTU = require("modbus-serial");
-    const net = require("net");
     const protocol = require("./lightweight-protocol");
+
+    // 全局防抖缓存：防止多个节点重复处理同一个按键事件
+    const globalDebounceCache = new Map();  // key: "switchId-buttonNumber", value: timestamp
     
     // 串口列表API - 支持Windows、Linux、macOS所有串口设备
     RED.httpAdmin.get('/modbus-slave-switch/serialports', async function(req, res) {
@@ -60,60 +61,65 @@ 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);
-        
+
+        // 继电器路数转换：用户输入1-32路，Modbus使用0-31
+        const userCoilNumber = parseInt(config.targetCoilNumber) || 1;  // 用户输入的路数（1-32）
+        const modbusCoilNumber = userCoilNumber - 1;  // Modbus线圈编号（0-31）
+
         // 配置参数
         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",         // 面板品牌（默认亖米）
+            buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式
             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        // 目标继电器线圈编号
+            targetCoilNumber: modbusCoilNumber  // 目标继电器线圈编号（0-31，从用户输入的1-32转换）
         };
-        
+
         node.currentState = false;
         node.mqttClient = null;
-        node.rs485Client = new ModbusRTU();  // RS-485总线客户端（仅串口模式使用）
-        node.tcpSocket = null;  // TCP Socket（TCP模式使用）
-        node.isRs485Connected = false;
-        node.reconnectTimer = null;
         node.isClosing = false;
+        node.lastTriggerTime = 0;  // 上次触发时间（用于场景模式防抖）
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
-        
-        // TCP帧缓冲区（用于处理分包和粘包）
-        node.frameBuffer = Buffer.alloc(0);
-        
+
         // 命令队列（处理多个按键同时按下）- 带时间戳
         node.commandQueue = [];
         node.isProcessingCommand = false;
-        
+
         // 指示灯反馈队列（40ms间隔发送）- 带时间戳
         node.ledFeedbackQueue = [];
         node.isProcessingLedFeedback = false;
-        
+
         // 队列超时时间（3秒）
         node.queueTimeout = 3000;
-        
+
+        // 防死循环：记录最后一次状态变化的时间戳和值
+        node.lastStateChange = {
+            timestamp: 0,
+            value: false
+        };
+
         // 节点初始化标志（用于静默初始化期间的警告）
         node.isInitializing = true;
-        
+
         // 节点关闭标志（用于静默关闭期间的警告）
         node.isClosing = false;
         
@@ -198,278 +204,129 @@ 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主机地址未配置");
-                    }
-                    
-                    // 使用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) {
-                        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.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();
-                
-                // 清理连接
-                if (node.tcpSocket) {
-                    node.tcpSocket.destroy();
-                    node.tcpSocket = null;
-                }
-                
-                // 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.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未初始化，无法监听数据');
-                }
+            // 使用共享连接配置的数据监听器
+            if (node.serialPortConfig) {
+                // 定义数据监听器函数（静默处理，只在匹配时输出日志）
+                node.serialDataListener = (data) => {
+                    node.handleRs485Data(data);
+                };
+
+                // 注册到共享连接配置
+                node.serialPortConfig.registerDataListener(node.serialDataListener);
             } else {
-                // 串口模式：监听串口数据（串口通常自动处理帧边界）
-                if (node.rs485Client._port) {
-                    node.rs485Client._port.on('data', (data) => {
-                        node.handleRs485Data(data);
-                    });
-                    node.log('串口数据监听已启动');
-                } else {
-                    node.error('串口未初始化，无法监听数据');
-                }
-            }
-        };
-        
-        // 处理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;
+                    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) {
+                    return; // 静默忽略REPORT帧
+                }
+
                 // 检测是否是按键按下事件
                 const buttonEvent = protocol.detectButtonPress(frame);
                 if (!buttonEvent) {
-                    node.log(`不是按键事件（设备类型=${frame.deviceType} 数据类型=${frame.dataType} 操作码=${frame.opCode}）`);
-                    return;
+                    return; // 静默忽略非按键事件
                 }
-                
-                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') {
-                        node.log(`匹配成功！面板${node.config.switchId} 按键${node.config.buttonNumber} 状态=${buttonEvent.state ? 'ON' : 'OFF'}`);
-                        // 发送MQTT命令到继电器
-                        node.sendMqttCommand(buttonEvent.state);
-                    } else if (buttonEvent.type === 'multi') {
-                        node.log(`匹配成功！面板${node.config.switchId} 多键按钮${node.config.buttonNumber} 状态=${buttonEvent.state ? 'ON' : 'OFF'}`);
-                        // 发送MQTT命令到继电器
-                        node.sendMqttCommand(buttonEvent.state);
+                    // 保存原始的deviceAddr和channel，用于LED反馈
+                    node.buttonDeviceAddr = buttonEvent.deviceAddr;
+                    node.buttonChannel = buttonEvent.channel;
+                    const isSceneMode = node.config.buttonType === 'scene' || buttonEvent.deviceType === 0x07;
+
+                    // 全局防抖：防止多个节点重复处理同一个按键
+                    const debounceKey = `${node.config.switchId}-${node.config.buttonNumber}`;
+                    const now = Date.now();
+                    const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+
+                    // 全局防抖：200ms内只触发一次（开关和场景统一防抖时间）
+                    if (now - lastTriggerTime < 200) {
+                        return; // 静默忽略重复触发
                     }
-                } else {
-                    if (buttonEvent.raw.localAddr !== node.config.switchId) {
-                        node.log(`面板地址不匹配: 收到${buttonEvent.raw.localAddr} 期望${node.config.switchId}`);
+                    globalDebounceCache.set(debounceKey, now);
+
+                    if (isSceneMode) {
+                        node.log(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
+                        // 场景模式：切换状态（每次触发时翻转）
+                        node.currentState = !node.currentState;
+                        node.sendMqttCommand(node.currentState);
                     } else {
-                        node.log(`按键编号不匹配: 收到${actualButtonNumber} 期望${node.config.buttonNumber}`);
+
+                        // 开关模式：根据状态发送ON/OFF
+                        node.log(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
+                        node.sendMqttCommand(buttonEvent.state);
                     }
                 }
+                // 不匹配的节点静默忽略，不输出任何日志
             } catch (err) {
                 node.error(`解析RS-485数据失败: ${err.message}`);
-                node.error(`错误数据: ${Array.from(data).map(b => b.toString(16).padStart(2, '0').toUpperCase()).join(' ')}`);
             }
         };
         
-        // 发送MQTT命令到继电器（入队）
+        // 发送命令到继电器（通过MQTT，由主站节点统一处理）
         node.sendMqttCommand = function(state) {
             if (!node.mqttClient || !node.mqttClient.connected) {
                 node.warn('MQTT未连接，无法发送命令');
                 return;
             }
-            
-            // 清理过期队列项（超过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}`);
-            
-            // 启动队列处理
-            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}`);
+                }
+                // 成功时不输出日志，减少总线负担
+            });
         };
         
         // 处理命令队列（防止多个按键同时按下造成冲突）
@@ -506,17 +363,16 @@ module.exports = function(RED) {
                             }
                         });
                     });
-                    
-                    node.log(`MQTT命令已发送: ${command} → ${node.commandTopic}`);
+
                     node.currentState = state;
                     node.updateStatus();
-                    
+
                     // 队列间隔40ms（避免MQTT broker过载）
                     if (node.commandQueue.length > 0) {
                         await new Promise(resolve => setTimeout(resolve, 40));
                     }
                 } catch (err) {
-                    node.error(`发布MQTT命令失败: ${err.message}`);
+                    node.error(`MQTT发送失败: ${err.message}`);
                 }
             }
             
@@ -525,21 +381,23 @@ module.exports = function(RED) {
         
         // 发送控制指令到物理开关面板（控制指示灯等）- 入队
         node.sendCommandToPanel = function(state) {
-            if (!node.isRs485Connected) {
+            // 检查连接状态
+            if (!node.serialPortConfig || !node.serialPortConfig.connection) {
                 // 初始化期间静默警告
                 if (!node.isInitializing) {
-                    node.warn('RS-485未连接，无法发送指示灯反馈');
+                    node.warn('RS-485连接未建立，无法发送指示灯反馈');
                 }
                 return;
             }
-            
+
             // 清理过期队列项（超过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();
         };
@@ -581,44 +439,49 @@ module.exports = function(RED) {
                 const state = item.state;
                 
                 try {
-                    // 根据按键编号反推设备地址和通道（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.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反馈');
-                        }
+                    // 使用保存的原始deviceAddr和channel（从按键事件中获取）
+                    // 如果没有保存，则根据按键编号反推（兼容旧版本）
+                    const deviceAddr = node.buttonDeviceAddr || (Math.floor((node.config.buttonNumber - 1) / 4) + 1);
+                    const channel = node.buttonChannel || (((node.config.buttonNumber - 1) % 4) + 1);
+
+                    // 根据按钮类型选择协议类型
+                    // 开关模式：使用SET协议（0x03），面板LED需要接收SET指令
+                    // 场景模式：使用REPORT协议（0x04），面板LED需要接收REPORT指令
+                    let command;
+                    if (node.config.buttonType === 'scene') {
+                        // 场景模式：使用REPORT协议
+                        command = protocol.buildSingleLightReport(
+                            node.config.switchId,  // 本地地址（面板地址）
+                            deviceAddr,            // 设备地址（从按键事件中获取）
+                            channel,               // 通道（从按键事件中获取）
+                            state
+                        );
                     } else {
-                        // 串口模式
-                        if (node.rs485Client._port) {
-                            node.rs485Client._port.write(command);
-                            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反馈');
-                        }
+                        // 开关模式（默认）：使用SET协议
+                        command = protocol.buildSingleLightCommand(
+                            node.config.switchId,  // 本地地址（面板地址）
+                            deviceAddr,            // 设备地址（从按键事件中获取）
+                            channel,               // 通道（从按键事件中获取）
+                            state
+                        );
                     }
-                    
-                    // 队列间隔100ms（确保RS-485总线有足够时间处理）
+
+                    // 发送到RS-485总线（使用共享连接配置）
+                    if (node.serialPortConfig) {
+                        node.serialPortConfig.write(command, (err) => {
+                            if (err) {
+                                node.error(`LED反馈失败: ${err.message}`);
+                            }
+                            // 成功时不输出日志，减少总线负担
+                        });
+                    } else {
+                        node.warn('RS-485连接未配置');
+                    }
+
+                    // 队列间隔20ms（优化速度，确保200个节点能快速反馈）
+                    // 20ms × 200节点 = 4秒完成所有反馈
                     if (node.ledFeedbackQueue.length > 0) {
-                        await new Promise(resolve => setTimeout(resolve, 100));
+                        await new Promise(resolve => setTimeout(resolve, 20));
                     }
                 } catch (err) {
                     node.error(`发送LED反馈失败: ${err.message}`);
@@ -676,9 +539,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}`);
             }
             
             // 尝试连接函数
@@ -697,6 +558,7 @@ module.exports = function(RED) {
                     lastConnectAttempt = Date.now();
                     
                     node.mqttClient.on('connect', () => {
+                        node.mqttConnected = true;
                         node.log(`MQTT已连接: ${brokerUrl}`);
                         
                         // 成功连接后，更新配置的broker地址（下次优先使用成功的地址）
@@ -809,13 +671,30 @@ 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();
-                            
+
                             // 发送控制指令到物理开关面板（同步指示灯等）
+                            // 场景模式和开关模式都发送LED反馈（使用原始deviceAddr和channel）
                             node.sendCommandToPanel(node.currentState);
-                            
+
                             // 输出状态
                             node.send({
                                 payload: node.currentState,
@@ -890,34 +769,46 @@ module.exports = function(RED) {
                 node.reconnectTimer = null;
             }
             
-            // 关闭TCP连接
-            if (node.tcpSocket && !node.tcpSocket.destroyed) {
-                try {
-                    node.tcpSocket.destroy();
-                    node.log('TCP连接已关闭');
-                } catch (err) {
-                    node.warn(`关闭TCP连接时出错: ${err.message}`);
-                }
-                node.tcpSocket = null;
-            }
+            // 清理队列（释放内存）
+            node.commandQueue = [];
+            node.ledFeedbackQueue = [];
+            node.frameBuffer = Buffer.alloc(0);
             
-            // 关闭串口RS-485连接
-            if (node.rs485Client && node.isRs485Connected && node.config.connectionType !== "tcp") {
+            // 注销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();
             }