node-red-contrib-symi-modbus 2.7.4 → 2.7.6

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,6 +353,28 @@ 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;
@@ -118,6 +392,12 @@ module.exports = function(RED) {
             value: false
         };
 
+        // 防止LED反馈重复发送：记录最后一次LED反馈的时间戳和值
+        node.lastLedFeedback = {
+            timestamp: 0,
+            value: false
+        };
+
         // 节点初始化标志（用于静默初始化期间的警告）
         node.isInitializing = true;
 
@@ -304,7 +584,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 +659,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发送命令，由主站节点统一处理）
@@ -469,10 +808,26 @@ module.exports = function(RED) {
                 return;
             }
 
-            // 清理过期队列项（超过3秒）
+            // 防止重复发送：如果状态相同且时间间隔小于100ms，跳过
             const now = Date.now();
+            const timeSinceLastFeedback = now - node.lastLedFeedback.timestamp;
+            const stateChanged = (state !== node.lastLedFeedback.value);
+
+            if (!stateChanged && timeSinceLastFeedback < 100) {
+                node.debug(`跳过重复LED反馈（状态未变化，间隔${timeSinceLastFeedback}ms）`);
+                return;
+            }
+
+            // 清理过期队列项（超过3秒）
             node.ledFeedbackQueue = node.ledFeedbackQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
 
+            // 检查队列中是否已有相同状态的反馈（去重）
+            const hasSameState = node.ledFeedbackQueue.some(item => item.state === state);
+            if (hasSameState) {
+                node.debug(`队列中已有相同状态的LED反馈，跳过添加`);
+                return;
+            }
+
             // 加入LED反馈队列（带时间戳）
             // 注意：这里不指定协议类型，在发送时根据情况选择
             node.ledFeedbackQueue.push({ state, timestamp: now });
@@ -481,83 +836,107 @@ module.exports = function(RED) {
             node.processLedFeedbackQueue();
         };
         
-        // 处理LED反馈队列（基于面板ID的固定延迟）
+        // 处理LED反馈队列（20ms间隔串行发送）
         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));
-            }
-            
+
+            // 记录队列开始处理时间
+            const queueStartTime = Date.now();
+            const queueLength = node.ledFeedbackQueue.length;
+
             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;
                 }
-                
+
                 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
+
+                    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控制帧失败`);
+                            continue;
+                        }
                     } else {
-                        // 开关模式（默认）：使用SET协议
-                        command = protocol.buildSingleLightCommand(
-                            node.config.switchId,  // 本地地址（面板地址）
-                            deviceAddr,            // 设备地址（从按键事件中获取）
-                            channel,               // 通道（从按键事件中获取）
-                            state
-                        );
+                        // RS-485模式：使用轻量级协议
+                        // 使用初始化时计算的deviceAddr和channel
+                        // 当物理按键按下时，会更新为实际的deviceAddr和channel
+                        const deviceAddr = node.buttonDeviceAddr;
+                        const channel = node.buttonChannel;
+
+                        // 根据按钮类型选择协议类型
+                        // 开关模式：使用SET协议（0x03），面板LED需要接收SET指令
+                        // 场景模式：使用REPORT协议（0x04），面板LED需要接收REPORT指令
+                        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
+                            );
+                        }
                     }
 
-                    // 发送到RS-485总线（使用共享连接配置）
+                    // 发送到RS-485总线或Mesh网关（使用共享连接配置）
                     if (node.serialPortConfig) {
                         node.serialPortConfig.write(command, (err) => {
                             if (err) {
                                 node.error(`LED反馈失败: ${err.message}`);
                             } else {
+                                // 记录最后一次LED反馈的时间戳和值
+                                node.lastLedFeedback.timestamp = Date.now();
+                                node.lastLedFeedback.value = state;
+
                                 // 输出调试日志，确认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}]`);
+                                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}]`);
+                                }
                             }
                         });
                     } else {
-                        node.warn('RS-485连接未配置');
+                        node.warn('连接未配置');
                     }
 
                     // 队列间隔20ms（优化速度，确保200个节点能快速反馈）
@@ -567,9 +946,16 @@ module.exports = function(RED) {
                     }
                 } catch (err) {
                     node.error(`发送LED反馈失败: ${err.message}`);
+                    // LED反馈失败不中断队列，继续处理下一个
                 }
             }
-            
+
+            // 队列处理完成，输出统计信息
+            const queueDuration = Date.now() - queueStartTime;
+            if (queueLength > 1) {
+                node.debug(`LED反馈队列处理完成：${queueLength}个任务，耗时${queueDuration}ms`);
+            }
+
             node.isProcessingLedFeedback = false;
         };
         
@@ -842,35 +1228,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();
         });
         
         // 节点关闭时清理