node-red-contrib-symi-modbus 2.6.8 → 2.6.9

package/nodes/modbus-slave-switch.js

@@ -2,10 +2,256 @@ module.exports = function(RED) {
     "use strict";
     const mqtt = require("mqtt");
     const protocol = require("./lightweight-protocol");
+    const meshProtocol = require("./mesh-protocol")(RED);
+    const storage = require('node-persist');
+    const path = require('path');
+    const os = require('os');
 
     // 全局防抖缓存：防止多个节点重复处理同一个按键事件
     const globalDebounceCache = new Map();  // key: "switchId-buttonNumber", value: timestamp
     
+    // 初始化Mesh设备持久化存储
+    const meshPersistDir = path.join(RED.settings.userDir || os.homedir() + '/.node-red', 'mesh-devices-persist');
+    let meshStorageInitialized = false;
+
+    async function initMeshStorage() {
+        if (meshStorageInitialized) {
+            return;
+        }
+        try {
+            await storage.init({
+                dir: meshPersistDir,
+                stringify: JSON.stringify,
+                parse: JSON.parse,
+                encoding: 'utf8',
+                logging: false,
+                ttl: false,
+                expiredInterval: 2 * 60 * 1000,
+                forgiveParseErrors: true
+            });
+            meshStorageInitialized = true;
+            RED.log.info(`Mesh设备持久化存储初始化成功: ${meshPersistDir}`);
+        } catch (err) {
+            RED.log.error(`Mesh设备持久化存储初始化失败: ${err.message}`);
+            throw err;
+        }
+    }
+
+    // Mesh设备发现API（使用共享连接）
+    RED.httpAdmin.post('/symi-mesh/discover', async function(req, res) {
+        try {
+            const serialPortConfigId = req.body.serialPortConfig;
+            RED.log.info(`[Mesh设备发现] 收到请求，连接配置ID: ${serialPortConfigId}`);
+
+            if (!serialPortConfigId) {
+                RED.log.warn('[Mesh设备发现] 缺少连接配置参数');
+                return res.status(400).json({error: '缺少连接配置'});
+            }
+
+            // 获取配置节点
+            const serialPortConfig = RED.nodes.getNode(serialPortConfigId);
+            if (!serialPortConfig) {
+                RED.log.warn(`[Mesh设备发现] 连接配置节点不存在: ${serialPortConfigId}`);
+                return res.status(400).json({error: '连接配置不存在，请先创建RS-485连接配置'});
+            }
+
+            RED.log.info(`[Mesh设备发现] 配置节点类型: ${serialPortConfig.type || '未知'}`);
+            RED.log.info(`[Mesh设备发现] 连接类型: ${serialPortConfig.connectionType || '串口'}`);
+
+            // 初始化持久化存储
+            await initMeshStorage();
+
+            // 发送设备列表请求
+            const requestFrame = meshProtocol.buildGetDeviceListFrame();
+            RED.log.info(`[Mesh设备发现] 发送设备列表请求: ${requestFrame.toString('hex').toUpperCase()}`);
+
+            // 设置响应超时
+            let timeoutHandle;
+            let isCompleted = false;
+            let dataHandler = null;
+
+            const completeRequest = async (devices, reason) => {
+                if (isCompleted) return;
+                isCompleted = true;
+
+                clearTimeout(timeoutHandle);
+
+                // 注销数据监听器
+                if (dataHandler) {
+                    serialPortConfig.unregisterDataListener(dataHandler);
+                    RED.log.info(`[Mesh设备发现] 已注销数据监听器`);
+                }
+
+                if (devices.length === 0) {
+                    RED.log.warn(`[Mesh设备发现] 未发现设备 (${reason || '超时'})`);
+                } else {
+                    RED.log.info(`[Mesh设备发现] 发现 ${devices.length} 个设备`);
+
+                    // 持久化保存设备列表（MAC地址 → 短地址映射）
+                    const deviceMap = {};
+                    devices.forEach(device => {
+                        deviceMap[device.mac] = {
+                            shortAddr: device.shortAddr,
+                            type: device.type,
+                            buttons: device.buttons,
+                            lastUpdate: Date.now()
+                        };
+                        RED.log.info(`  - MAC: ${device.mac}, 短地址: ${device.shortAddr}, 类型: ${device.type}, 按键数: ${device.buttons}`);
+                    });
+
+                    await storage.setItem('meshDeviceMap', deviceMap);
+                    RED.log.info(`[Mesh设备发现] 设备列表已保存到持久化存储`);
+                }
+
+                res.json(devices);
+            };
+
+            timeoutHandle = setTimeout(() => {
+                RED.log.warn(`[Mesh设备发现] 5秒超时，未收到完整响应`);
+                completeRequest([], '超时');
+            }, 5000);
+
+            // 收集响应帧
+            const responseFrames = [];
+            let totalDevices = 0;
+            let receivedDevices = 0;
+            let buffer = Buffer.alloc(0);
+
+            dataHandler = (data) => {
+                // 拼接数据到缓冲区
+                buffer = Buffer.concat([buffer, data]);
+                RED.log.info(`[Mesh设备发现] 收到数据: ${data.toString('hex').toUpperCase()}, 缓冲区总长: ${buffer.length}`);
+
+                // 解析所有完整的帧
+                // 协议格式: 53 92 00 10 [总数] [索引] [MAC 6字节] [短地址 2字节] [vendor_id 2字节] [dev_type] [dev_sub_type] [online/status] [resv] [校验]
+                // 总长度: 1+1+1+1+16+1 = 21字节
+                while (buffer.length >= 21) {
+                    // 查找帧头 0x53
+                    const headerIndex = buffer.indexOf(0x53);
+                    if (headerIndex === -1) {
+                        buffer = Buffer.alloc(0);
+                        break;
+                    }
+
+                    if (headerIndex > 0) {
+                        buffer = buffer.slice(headerIndex);
+                    }
+
+                    if (buffer.length < 21) break;
+
+                    // 检查是否是设备列表响应 (0x53 0x92 0x00 0x10)
+                    if (buffer[1] !== 0x92 || buffer[2] !== 0x00 || buffer[3] !== 0x10) {
+                        buffer = buffer.slice(1);
+                        continue;
+                    }
+
+                    // 提取完整帧（21字节）
+                    const frame = buffer.slice(0, 21);
+                    buffer = buffer.slice(21);
+
+                    // 解析帧数据
+                    const deviceCount = frame[4]; // 设备总数
+                    const index = frame[5];       // 索引 (00, 01, 02...)
+                    const mac = Array.from(frame.slice(6, 12))
+                        .map(b => b.toString(16).padStart(2, '0'))
+                        .join(':');
+                    const shortAddr = frame[12] | (frame[13] << 8); // 小端序
+                    const vendorId = frame[14] | (frame[15] << 8);  // 小端序
+                    const devType = frame[16];
+                    const devSubType = frame[17]; // 按键数
+                    const online = frame[18];
+                    const resv = frame[19];
+                    const checksum = frame[20];
+
+                    RED.log.info(`[Mesh设备发现] 收到响应帧，索引: ${index}/${deviceCount-1}, 完整帧: ${frame.toString('hex').toUpperCase()}`);
+
+                    // 第一帧：记录设备总数
+                    if (totalDevices === 0) {
+                        totalDevices = deviceCount;
+                        RED.log.info(`[Mesh设备发现] 设备总数: ${totalDevices}`);
+                        if (totalDevices === 0) {
+                            completeRequest([], '网关下无设备');
+                            return;
+                        }
+                    }
+
+                    // 只保存开关类型的设备（devType=0x01或0x02）
+                    if ((devType === 0x01 || devType === 0x02) && devSubType > 0) {
+                        responseFrames.push({
+                            shortAddr,
+                            mac,
+                            type: devType,
+                            buttons: devSubType
+                        });
+                        RED.log.info(`  - 索引${index}: MAC=${mac}, 短地址=0x${shortAddr.toString(16).toUpperCase().padStart(4, '0')}, 类型=0x${devType.toString(16).toUpperCase()}, 按键数=${devSubType}, 在线=${online}`);
+                    } else {
+                        RED.log.debug(`  - 索引${index}: 跳过非开关设备，MAC=${mac}, 类型=0x${devType.toString(16).toUpperCase()}`);
+                    }
+
+                    receivedDevices++;
+                    RED.log.info(`[Mesh设备发现] 已收到 ${receivedDevices}/${totalDevices} 个设备数据帧`);
+
+                    // 如果收到所有设备数据，返回结果
+                    if (receivedDevices >= totalDevices) {
+                        RED.log.info(`[Mesh设备发现] 所有设备数据接收完成，共${responseFrames.length}个开关设备`);
+                        completeRequest(responseFrames, '完成');
+                        return;
+                    }
+                }
+            };
+
+            // 使用共享连接（TCP和串口都一样）
+            RED.log.info(`[Mesh设备发现] 使用共享连接（${serialPortConfig.connectionType}）`);
+
+            // 注册数据监听器
+            serialPortConfig.registerDataListener(dataHandler);
+
+            // 发送请求
+            try {
+                serialPortConfig.write(requestFrame, (err) => {
+                    if (err) {
+                        RED.log.error(`[Mesh设备发现] 发送请求失败: ${err.message}`);
+                        serialPortConfig.unregisterDataListener(dataHandler);
+                        completeRequest([], `发送失败: ${err.message}`);
+                    } else {
+                        RED.log.info(`[Mesh设备发现] 请求已发送，等待响应...`);
+                    }
+                });
+            } catch (err) {
+                RED.log.error(`[Mesh设备发现] 发送请求异常: ${err.message}`);
+                serialPortConfig.unregisterDataListener(dataHandler);
+                return res.status(500).json({error: `发送请求失败: ${err.message}`});
+            }
+
+        } catch (err) {
+            RED.log.error(`Mesh设备发现失败: ${err.message}`);
+            res.status(500).json({error: err.message});
+        }
+    });
+
+    // 获取已保存的Mesh设备列表API
+    RED.httpAdmin.get('/symi-mesh/devices', async function(req, res) {
+        try {
+            await initMeshStorage();
+            const deviceMap = await storage.getItem('meshDeviceMap') || {};
+
+            // 转换为数组格式
+            const devices = Object.keys(deviceMap).map(mac => {
+                return {
+                    mac: mac,
+                    shortAddr: deviceMap[mac].shortAddr,
+                    type: deviceMap[mac].type,
+                    buttons: deviceMap[mac].buttons
+                };
+            });
+
+            res.json(devices);
+        } catch (err) {
+            RED.log.error(`获取Mesh设备列表失败: ${err.message}`);
+            res.status(500).json({error: err.message});
+        }
+    });
+
     // 串口列表API - 支持Windows、Linux、macOS所有串口设备
     RED.httpAdmin.get('/modbus-slave-switch/serialports', async function(req, res) {
         try {
@@ -87,9 +333,15 @@ module.exports = function(RED) {
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay",
             // 开关面板配置
             switchBrand: config.switchBrand || "symi",         // 面板品牌（默认亖米）
-            buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式
+            buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式，mesh=Mesh模式
             switchId: parseInt(config.switchId) || 0,           // 开关ID（0-255，物理面板地址）
             buttonNumber: parseInt(config.buttonNumber) || 1,  // 按钮编号（1-8）
+            // Mesh模式配置
+            meshMacAddress: config.meshMacAddress || "",        // Mesh设备MAC地址
+            meshShortAddress: parseInt(config.meshShortAddress) || 0,  // Mesh设备短地址
+            meshButtonNumber: parseInt(config.meshButtonNumber) || 1,  // Mesh按键编号（1-6）
+            meshTotalButtons: parseInt(config.meshTotalButtons) || 1,  // Mesh开关总路数（1-6）
+            // 目标继电器配置
             targetSlaveAddress: parseInt(config.targetSlaveAddress) || 10,  // 目标继电器从站地址
             targetCoilNumber: modbusCoilNumber  // 目标继电器线圈编号（0-31，从用户输入的1-32转换）
         };
@@ -101,16 +353,37 @@ module.exports = function(RED) {
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
 
+        // Mesh模式状态缓存
+        node.meshCurrentStates = null;  // Mesh设备当前状态（用于保持其他路不变）
+
+        // Mesh模式：从持久化存储更新短地址（如果MAC地址对应的短地址发生变化）
+        if (node.config.buttonType === 'mesh' && node.config.meshMacAddress) {
+            initMeshStorage().then(async () => {
+                try {
+                    const deviceMap = await storage.getItem('meshDeviceMap') || {};
+                    const savedDevice = deviceMap[node.config.meshMacAddress];
+
+                    if (savedDevice && savedDevice.shortAddr !== node.config.meshShortAddress) {
+                        node.log(`Mesh设备短地址已更新: ${node.config.meshMacAddress} 从 ${node.config.meshShortAddress} 更新为 ${savedDevice.shortAddr}`);
+                        node.config.meshShortAddress = savedDevice.shortAddr;
+                    }
+                } catch (err) {
+                    node.warn(`更新Mesh设备短地址失败: ${err.message}`);
+                }
+            }).catch(err => {
+                node.warn(`初始化Mesh存储失败: ${err.message}`);
+            });
+        }
+
         // 命令队列（处理多个按键同时按下）- 带时间戳
         node.commandQueue = [];
         node.isProcessingCommand = false;
 
-        // 指示灯反馈队列（40ms间隔发送）- 带时间戳
-        node.ledFeedbackQueue = [];
-        node.isProcessingLedFeedback = false;
-
-        // 队列超时时间（3秒）
-        node.queueTimeout = 3000;
+        // LED反馈去重：记录最后一次发送的状态和时间戳（防止重复发送）
+        node.lastSentLedState = {
+            value: null,
+            timestamp: 0
+        };
 
         // 防死循环：记录最后一次状态变化的时间戳和值
         node.lastStateChange = {
@@ -224,8 +497,6 @@ module.exports = function(RED) {
                 // 结束初始化阶段（5秒后）- 避免部署时大量LED反馈同时发送
                 setTimeout(() => {
                     node.isInitializing = false;
-                    // 初始化完成后，处理积累的LED反馈队列
-                    node.processLedFeedbackQueue();
                 }, 5000);
 
                 // 监听物理开关面板的按键事件
@@ -304,7 +575,13 @@ module.exports = function(RED) {
         // 处理RS-485接收到的数据
         node.handleRs485Data = function(data) {
             try {
-                // 解析轻量级协议帧
+                // 如果是Mesh模式，使用Mesh协议解析
+                if (node.config.buttonType === 'mesh') {
+                    node.handleMeshData(data);
+                    return;
+                }
+
+                // 解析轻量级协议帧（RS-485模式）
                 const frame = protocol.parseFrame(data);
                 if (!frame) {
                     return; // 静默忽略无效帧
@@ -373,7 +650,60 @@ module.exports = function(RED) {
                 node.error(`解析RS-485数据失败: ${err.message}`);
             }
         };
-        
+
+        // 处理Mesh协议数据
+        node.handleMeshData = function(data) {
+            try {
+                // 解析Mesh状态事件
+                const event = meshProtocol.parseStatusEvent(data);
+                if (!event) {
+                    return; // 静默忽略无效帧
+                }
+
+                // 检查是否是我们监听的Mesh设备
+                if (event.shortAddr !== node.config.meshShortAddress) {
+                    return; // 不是我们的设备，忽略
+                }
+
+                // 检查消息类型
+                if (event.msgType !== meshProtocol.PROTOCOL.MSG_TYPE_SWITCH &&
+                    event.msgType !== meshProtocol.PROTOCOL.MSG_TYPE_SWITCH_6) {
+                    return; // 不是开关状态，忽略
+                }
+
+                // 获取按钮状态
+                if (!event.states || event.states.length < node.config.meshButtonNumber) {
+                    return; // 状态数据不完整
+                }
+
+                const buttonState = event.states[node.config.meshButtonNumber - 1];
+                if (buttonState === null) {
+                    return; // 状态未知，忽略
+                }
+
+                // 全局防抖：防止多个节点重复处理同一个按键
+                const debounceKey = `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
+                const now = Date.now();
+                const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+
+                // 全局防抖：200ms内只触发一次
+                if (now - lastTriggerTime < 200) {
+                    return; // 静默忽略重复触发
+                }
+                globalDebounceCache.set(debounceKey, now);
+
+                // 更新当前状态缓存（用于后续控制时保持其他路不变）
+                node.meshCurrentStates = event.states;
+
+                // 发送命令到继电器
+                node.debug(`Mesh开关${buttonState ? 'ON' : 'OFF'}: MAC=${node.config.meshMacAddress} 按键${node.config.meshButtonNumber}`);
+                node.sendMqttCommand(buttonState);
+
+            } catch (err) {
+                node.error(`解析Mesh数据失败: ${err.message}`);
+            }
+        };
+
         // 发送命令到继电器（支持两种模式：MQTT模式和内部事件模式）
         node.sendMqttCommand = function(state) {
             // 模式1：MQTT模式（通过MQTT发送命令，由主站节点统一处理）
@@ -458,7 +788,8 @@ module.exports = function(RED) {
             node.isProcessingCommand = false;
         };
         
-        // 发送控制指令到物理开关面板（控制指示灯等）- 入队
+        // 发送控制指令到物理开关面板（控制指示灯等）
+        // 直接发送到全局队列，由serial-port-config统一管理（20ms间隔串行发送）
         node.sendCommandToPanel = function(state) {
             // 检查连接状态
             if (!node.serialPortConfig || !node.serialPortConfig.connection) {
@@ -469,110 +800,83 @@ module.exports = function(RED) {
                 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();
-        };
-        
-        // 处理LED反馈队列（基于面板ID的固定延迟）
-        node.processLedFeedbackQueue = async function() {
-            if (node.isProcessingLedFeedback || node.ledFeedbackQueue.length === 0) {
-                return;
-            }
-            
-            // 初始化期间不处理LED反馈（避免部署时大量LED同时发送）
+            // 初始化期间不发送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));
+
+            // 防止重复发送：如果状态相同且时间间隔小于50ms，跳过
+            if (node.lastSentLedState.value === state && (now - node.lastSentLedState.timestamp) < 50) {
+                node.debug(`跳过重复LED反馈（状态未变化，间隔${now - node.lastSentLedState.timestamp}ms）`);
+                return;
             }
-            
-            while (node.ledFeedbackQueue.length > 0) {
-                const item = node.ledFeedbackQueue.shift();
-                
-                // 再次检查是否过期
-                if (Date.now() - item.timestamp >= node.queueTimeout) {
-                    node.warn(`丢弃过期LED反馈（${Date.now() - item.timestamp}ms）`);
-                    continue;
+
+            // 更新最后发送状态
+            node.lastSentLedState.value = state;
+            node.lastSentLedState.timestamp = now;
+
+            // 构建LED反馈协议帧
+            let command;
+
+            if (node.config.buttonType === 'mesh') {
+                // Mesh模式：发送Mesh控制帧
+                command = meshProtocol.buildSwitchControlFrame(
+                    node.config.meshShortAddress,
+                    node.config.meshButtonNumber,
+                    node.config.meshTotalButtons,
+                    state,
+                    node.meshCurrentStates || null
+                );
+
+                if (!command) {
+                    node.error(`构建Mesh控制帧失败`);
+                    return;
                 }
-                
-                const state = item.state;
-                
-                try {
-                    // 使用初始化时计算的deviceAddr和channel
-                    // 当物理按键按下时，会更新为实际的deviceAddr和channel
-                    const deviceAddr = node.buttonDeviceAddr;
-                    const channel = node.buttonChannel;
-
-                    // 根据按钮类型选择协议类型
-                    // 开关模式：使用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 {
-                        // 开关模式（默认）：使用SET协议
-                        command = protocol.buildSingleLightCommand(
-                            node.config.switchId,  // 本地地址（面板地址）
-                            deviceAddr,            // 设备地址（从按键事件中获取）
-                            channel,               // 通道（从按键事件中获取）
-                            state
-                        );
-                    }
+            } else {
+                // RS-485模式：使用轻量级协议
+                const deviceAddr = node.buttonDeviceAddr;
+                const channel = node.buttonChannel;
 
-                    // 发送到RS-485总线（使用共享连接配置）
-                    if (node.serialPortConfig) {
-                        node.serialPortConfig.write(command, (err) => {
-                            if (err) {
-                                node.error(`LED反馈失败: ${err.message}`);
-                            } else {
-                                // 输出调试日志，确认LED反馈已发送（包含协议帧十六进制）
-                                const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
-                                node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
-                            }
-                        });
-                    } else {
-                        node.warn('RS-485连接未配置');
-                    }
+                // 根据按钮类型选择协议类型
+                if (node.config.buttonType === 'scene') {
+                    // 场景模式：使用REPORT协议
+                    command = protocol.buildSingleLightReport(
+                        node.config.switchId,
+                        deviceAddr,
+                        channel,
+                        state
+                    );
+                } else {
+                    // 开关模式（默认）：使用SET协议
+                    command = protocol.buildSingleLightCommand(
+                        node.config.switchId,
+                        deviceAddr,
+                        channel,
+                        state
+                    );
+                }
+            }
 
-                    // 队列间隔20ms（优化速度，确保200个节点能快速反馈）
-                    // 20ms × 200节点 = 4秒完成所有反馈
-                    if (node.ledFeedbackQueue.length > 0) {
-                        await new Promise(resolve => setTimeout(resolve, 20));
+            // 直接发送到全局队列（由serial-port-config统一管理，20ms间隔串行发送）
+            node.serialPortConfig.write(command, (err) => {
+                if (err) {
+                    node.error(`LED反馈失败: ${err.message}`);
+                } else {
+                    // 输出调试日志，确认LED反馈已发送（包含协议帧十六进制）
+                    const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
+                    if (node.config.buttonType === 'mesh') {
+                        node.log(`Mesh LED反馈已发送：MAC=${node.config.meshMacAddress} 按钮${node.config.meshButtonNumber} = ${state ? 'ON' : 'OFF'} [${hexStr}]`);
+                    } else {
+                        const deviceAddr = node.buttonDeviceAddr;
+                        const channel = node.buttonChannel;
+                        node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
                     }
-                } catch (err) {
-                    node.error(`发送LED反馈失败: ${err.message}`);
                 }
-            }
-            
-            node.isProcessingLedFeedback = false;
+            });
         };
-        
+
         // 更新节点状态显示
         node.updateStatus = function() {
             const rs485Status = node.isRs485Connected ? 'OK' : 'ERR';
@@ -691,55 +995,59 @@ module.exports = function(RED) {
                     node.mqttClient.on('error', (err) => {
                         // 连接失败，尝试下一个候选地址
                         const errorMsg = err.message || err.code || '连接失败';
-                        node.warn(`MQTT连接错误: ${errorMsg} (broker: ${brokerUrl})`);
-                        
                         const now = Date.now();
+
+                        // 使用日志限流，避免长期断网时产生垃圾日志
+                        const shouldLogError = (now - node.lastMqttErrorLog) > node.errorLogInterval;
+                        if (shouldLogError) {
+                            node.debug(`MQTT连接错误: ${errorMsg} (broker: ${brokerUrl})`);
+                        }
+
                         const timeSinceLastAttempt = now - lastConnectAttempt;
-                        
-                        // 避免频繁重试（至少等待1秒），但仍要记录错误
+
+                        // 避免频繁重试（至少等待1秒）
                         if (timeSinceLastAttempt < 1000) {
                             setTimeout(() => {
                                 tryNextBroker();
                             }, 1000);
                             return;
                         }
-                        
+
                         tryNextBroker();
-                        
+
                         function tryNextBroker() {
                             // 尝试下一个候选地址
                             currentCandidateIndex = (currentCandidateIndex + 1) % brokerCandidates.length;
                             const nextBroker = brokerCandidates[currentCandidateIndex];
-                            
+
                             // 如果回到第一个地址，说明所有地址都试过了
                             if (currentCandidateIndex === 0) {
                                 // 判断是否是局域网IP配置（只有一个候选地址）
                                 const isSingleIpConfig = brokerCandidates.length === 1;
-                                
-                                if (isSingleIpConfig) {
-                                    // 局域网IP配置失败，立即输出错误（不受日志限流限制）
-                                    node.error(`MQTT连接失败: ${errorMsg}`);
-                                    node.error(`无法连接到MQTT broker: ${brokerCandidates[0]}`);
-                                    node.error('请检查：1) MQTT broker是否在该地址运行  2) 网络是否连通  3) 端口是否正确');
-                                    node.error('提示：可以使用命令测试: telnet 192.168.2.12 1883');
-                                } else {
-                                    // 多个fallback地址都失败，使用日志限流
-                                    const shouldLog = (now - node.lastMqttErrorLog) > node.errorLogInterval;
-                                    
-                                    if (shouldLog) {
-                                        node.error(`MQTT错误: ${errorMsg}`);
-                                        node.error(`所有MQTT broker候选地址都无法连接: ${brokerCandidates.join(', ')}`);
-                                        node.error('请检查：1) MQTT broker是否运行  2) 网络连接是否正常  3) broker地址是否正确');
-                                        node.error('提示：如果Node-RED运行在Docker容器中，可能需要使用host.docker.internal或容器IP [此错误将在10分钟后再次显示]');
-                                        node.lastMqttErrorLog = now;
+
+                                // 使用日志限流，避免长期断网时产生垃圾日志
+                                const shouldLog = (now - node.lastMqttErrorLog) > node.errorLogInterval;
+
+                                if (shouldLog) {
+                                    if (isSingleIpConfig) {
+                                        // 局域网IP配置失败，使用debug级别（不写入日志文件）
+                                        node.debug(`MQTT连接失败: ${errorMsg}`);
+                                        node.debug(`无法连接到MQTT broker: ${brokerCandidates[0]}`);
+                                        node.debug('请检查：1) MQTT broker是否在该地址运行  2) 网络是否连通  3) 端口是否正确');
+                                    } else {
+                                        // 多个fallback地址都失败，使用debug级别
+                                        node.debug(`MQTT错误: ${errorMsg}`);
+                                        node.debug(`所有MQTT broker候选地址都无法连接: ${brokerCandidates.join(', ')}`);
+                                        node.debug('请检查：1) MQTT broker是否运行  2) 网络连接是否正常  3) broker地址是否正确');
                                     }
+                                    node.lastMqttErrorLog = now;
                                 }
-                                
-                                // 5秒后重试第一个地址
+
+                                // 30秒后重试第一个地址（从5秒改为30秒，减少重试频率）
                                 setTimeout(() => {
                                     node.debug('重试连接MQTT broker...');
                                     tryConnect(brokerCandidates[0]);
-                                }, 5000);
+                                }, 30000);
                             } else {
                                 node.debug(`尝试备用MQTT broker: ${nextBroker}`);
                                 setTimeout(() => {
@@ -747,7 +1055,7 @@ module.exports = function(RED) {
                                 }, 500);  // 快速尝试下一个地址
                             }
                         }
-                        
+
                         node.updateStatus();
                     });
                     
@@ -758,16 +1066,16 @@ module.exports = function(RED) {
                     node.mqttClient.on('offline', () => {
                         const now = Date.now();
                         const shouldLog = (now - node.lastMqttErrorLog) > node.errorLogInterval;
-                        
+
                         if (shouldLog) {
-                            node.warn('MQTT离线，正在尝试重连...');
+                            node.debug('MQTT离线，正在尝试重连...');
                             node.lastMqttErrorLog = now;
                         }
-                        
+
                         // 尝试下一个候选地址
                         currentCandidateIndex = (currentCandidateIndex + 1) % brokerCandidates.length;
                         const nextBroker = brokerCandidates[currentCandidateIndex];
-                        
+
                         setTimeout(() => {
                             tryConnect(nextBroker);
                         }, 2000);
@@ -838,35 +1146,50 @@ module.exports = function(RED) {
         
         // 处理输入消息
         node.on('input', function(msg) {
-            if (!node.mqttClient || !node.mqttClient.connected) {
-                node.warn('MQTT未连接');
-                return;
-            }
-            
             let value = false;
-            
+
             // 解析输入值
             if (typeof msg.payload === 'boolean') {
                 value = msg.payload;
             } else if (typeof msg.payload === 'string') {
-                value = (msg.payload.toLowerCase() === 'on' || 
-                         msg.payload.toLowerCase() === 'true' || 
+                value = (msg.payload.toLowerCase() === 'on' ||
+                         msg.payload.toLowerCase() === 'true' ||
                          msg.payload === '1');
             } else if (typeof msg.payload === 'number') {
                 value = (msg.payload !== 0);
             }
-            
-            // 发布命令到MQTT
-            const command = value ? 'ON' : 'OFF';
-            node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
-                if (err) {
-                    node.error(`发布命令失败: ${err.message}`);
-                } else {
-                    node.log(`发送命令: ${command} 到 ${node.commandTopic}`);
-                    node.currentState = value;
-                    node.updateStatus();
-                }
+
+            // 更新当前状态
+            node.currentState = value;
+
+            // 输出消息到debug节点（无论是否使用MQTT）
+            node.send({
+                payload: value,
+                topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
+                switchId: node.config.switchId,
+                button: node.config.buttonNumber,
+                targetSlave: node.config.targetSlaveAddress,
+                targetCoil: node.config.targetCoilNumber,
+                source: 'input'
             });
+
+            // 如果启用MQTT，发布命令到MQTT
+            if (node.mqttClient && node.mqttClient.connected) {
+                const command = value ? 'ON' : 'OFF';
+                node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
+                    if (err) {
+                        node.error(`发布命令失败: ${err.message}`);
+                    } else {
+                        node.log(`发送命令: ${command} 到 ${node.commandTopic}`);
+                    }
+                });
+            } else {
+                // 本地模式：通过内部事件发送命令
+                node.sendMqttCommand(value);
+            }
+
+            // 更新状态显示
+            node.updateStatus();
         });
         
         // 节点关闭时清理
@@ -881,7 +1204,6 @@ module.exports = function(RED) {
             
             // 清理队列（释放内存）
             node.commandQueue = [];
-            node.ledFeedbackQueue = [];
             node.frameBuffer = Buffer.alloc(0);
             
             // 注销RS-485数据监听器（不关闭连接，由配置节点管理）