node-red-contrib-symi-modbus 2.8.8 → 2.8.9

package/README.md

@@ -187,6 +187,9 @@ node-red-restart
 4. **选择设备和按键**
    - Mesh设备: 从下拉框选择开关（显示格式：`MAC地址 (X路开关)`）
    - 按钮编号: 选择要使用的按键（1-6路）
+   - **无线模式**（可选）: 勾选此选项后，该按键不响应LED反馈
+     - 适用场景：按键用于触发场景（如全开/全关），继电器状态变化不应点亮该按键LED
+     - 例如：按键3控制线圈16（全开触发），勾选无线模式后，线圈0-15状态变化不会点亮按键3的LED
    - 多个节点可共享同一设备列表，无需重复扫描
 
 5. **配置目标继电器**
@@ -196,12 +199,13 @@ node-red-restart
 6. **部署流程**
    - 点击"完成"并部署
    - Mesh开关按键会自动控制对应继电器
-   - 继电器状态变化会自动反馈到Mesh开关LED
+   - 继电器状态变化会自动反馈到Mesh开关LED（无线模式按键除外）
 
 **Mesh模式特点**：
 - 无线控制，无需布线
 - 支持1-6路开关
 - 双向同步（按键→继电器，继电器→LED）
+- 支持无线模式（场景触发按键不响应LED反馈）
 - 设备列表持久化保存
 - 短地址自动更新（如果网关重新配网）
 - 与RS-485开关使用方式完全一致
@@ -884,28 +888,47 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.8.7 (2025-11-12)
+**当前版本**: v2.8.9 (2025-11-13)
+
+**v2.8.9 更新内容**：
+- 新增Mesh开关无线模式支持，适用于场景触发按键
+- 修复Mesh开关群控LED反馈问题，确保状态完全同步
+- 优化LED反馈防抖机制（100ms），智能合并多次状态变化
+- 群控多个继电器时，Mesh开关只发送一次LED反馈，包含所有按钮的最新状态
+- 修复串口永久连接机制，彻底解决部署时串口锁定问题
+- RS-485开关功能完全不受影响，保持稳定运行
 
 **核心特性**：
 - 支持Modbus RTU/TCP协议，兼容标准Modbus设备和TCP转RS485网关
 - 支持Symi RS-485开关和蓝牙Mesh开关，实现双向状态同步
+- 支持Mesh开关无线模式（场景触发按键不响应LED反馈）
 - 内置HomeKit网桥，支持Siri语音控制
 - 可视化控制看板，实时显示和控制所有继电器状态
 - 智能写入队列，支持大规模批量控制（160+继电器）流畅无卡顿
 - 完整的内存管理和错误处理，适合7x24小时长期稳定运行
 
+**Mesh开关LED反馈机制**：
+- 按键触发：100ms内完成控制和LED反馈，响应迅速
+- 继电器控制：100ms防抖，智能合并多次状态变化后发送一次LED反馈
+- 全控场景：无论多少个继电器同时变化，只发送一次LED反馈，包含所有按钮的最新状态
+- 无线模式：勾选无线模式的按键不响应LED反馈，适用于场景触发按键
+- 全局锁定：LED反馈发送期间（100ms），忽略所有Mesh面板的状态上报，避免误触发
+
 **稳定性保障**：
 - 连接永久保持：串口/TCP连接一旦建立就保持打开，避免部署时频繁开关导致的锁定问题
 - 内存泄漏防护：每5分钟自动检查并清理异常积压数据
 - 日志防护：错误日志限流，避免硬盘被填满
 - 配置持久化：所有配置和Mesh设备列表自动保存，重启后自动恢复
 - 断网/断电不影响：本地模式下完全脱离网络依赖
+- RS-485独立运行：RS-485开关功能完全独立，不受Mesh功能影响
 
 **实际使用场景**：
 - 主站轮询：200ms/台，支持5-10台从站设备
-- 开关面板：支持50个以内面板，约200个按钮（设计极限500+）
+- 开关面板：支持50个以内Mesh面板，约200个按钮
 - LED同步：部署/重启后1秒内完成所有LED状态同步
-- 批量控制：支持17通道全开/全关等批量操作，LED反馈流畅无卡顿
+- 批量控制：支持全开/全关等批量操作，LED反馈流畅无卡顿
+- 多面板支持：100个面板同时LED反馈仅需4秒（40ms间隔×100）
+- 场景触发：支持无线模式按键，不受LED反馈影响
 
 ## 许可证
 

package/nodes/mesh-protocol.js

@@ -24,6 +24,7 @@ module.exports = function(RED) {
         MSG_TYPE_CURTAIN: 0x05,     // 窗帘动作
         MSG_TYPE_CURTAIN_POS: 0x06, // 窗帘位置
         MSG_TYPE_THERMOSTAT: 0x07,  // 温控器
+        MSG_TYPE_SCENE: 0x38,       // 场景模式（无线开关）
         MSG_TYPE_SWITCH_6: 0x45,    // 6路开关状态
         // 设备类型
         DEVICE_TYPE_SWITCH: 0x01,
@@ -211,35 +212,73 @@ module.exports = function(RED) {
         const subOp = frame[2];
         const length = frame[3];
         const shortAddr = frame[4] | (frame[5] << 8); // 小端序
-        const msgType = frame[6];
+
+        // NODE_STATUS事件的数据格式：多个(msg_type + param)的组合
+        // 例如：53 80 06 06 07 01 02 01 0D 01 DA
+        // 02 01 = msg_type=0x02(开关状态) param=0x01(第一路关闭)
+        // 0D 01 = msg_type=0x0D(触发源) param=0x01(本地按键)
 
         const event = {
             subOp: subOp,
             shortAddr: shortAddr,
-            msgType: msgType
+            triggerSource: null  // 0=未知, 1=本地按键, 2=Mesh网络, 3=私有双控网络
         };
 
-        // 根据消息类型解析状态
-        if (msgType === PROTOCOL.MSG_TYPE_SWITCH) {
-            // 1-4路开关状态
-            const stateValue = frame[7];
-            event.states = parseMultiSwitchState(stateValue, 4);
-        } else if (msgType === PROTOCOL.MSG_TYPE_SWITCH_6) {
-            // 6路开关状态
-            const stateLow = frame[7];
-            const stateHigh = frame[8];
-            const stateValue = stateLow | (stateHigh << 8);
-            event.states = parseMultiSwitchState(stateValue, 6);
-        } else if (msgType === PROTOCOL.MSG_TYPE_DIMMER) {
-            // 调光灯状态
-            event.brightness = frame[7];
-            event.colorTemp = frame[8];
-        } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN) {
-            // 窗帘动作状态
-            event.action = frame[7]; // 0=停止, 1=打开中, 2=关闭中
-        } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN_POS) {
-            // 窗帘位置状态
-            event.position = frame[7]; // 0-100%
+        // 解析数据部分（从第6字节开始）
+        let offset = 6;
+        while (offset < frame.length - 1) {  // 最后一字节是校验
+            const msgType = frame[offset];
+            offset++;
+
+            if (offset >= frame.length - 1) break;
+
+            // 根据消息类型解析参数
+            if (msgType === PROTOCOL.MSG_TYPE_SWITCH) {
+                // 1-4路开关状态（1字节）
+                const stateValue = frame[offset];
+                event.msgType = msgType;
+                event.states = parseMultiSwitchState(stateValue, 4);
+                offset++;
+            } else if (msgType === PROTOCOL.MSG_TYPE_SWITCH_6) {
+                // 6路开关状态（2字节）
+                const stateLow = frame[offset];
+                const stateHigh = frame[offset + 1];
+                const stateValue = stateLow | (stateHigh << 8);
+                event.msgType = msgType;
+                event.states = parseMultiSwitchState(stateValue, 6);
+                offset += 2;
+            } else if (msgType === 0x0D) {
+                // 触发源（1字节）
+                // 0=未知, 1=本地按键, 2=Mesh网络, 3=私有双控网络
+                event.triggerSource = frame[offset];
+                offset++;
+            } else if (msgType === PROTOCOL.MSG_TYPE_DIMMER) {
+                // 调光灯状态（2字节）
+                event.msgType = msgType;
+                event.brightness = frame[offset];
+                event.colorTemp = frame[offset + 1];
+                offset += 2;
+            } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN) {
+                // 窗帘动作状态（1字节）
+                event.msgType = msgType;
+                event.action = frame[offset];
+                offset++;
+            } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN_POS) {
+                // 窗帘位置状态（1字节）
+                event.msgType = msgType;
+                event.position = frame[offset];
+                offset++;
+            } else if (msgType === PROTOCOL.MSG_TYPE_SCENE) {
+                // 场景模式（无线开关）（2字节：按键编号 + 状态）
+                // 例如：38 03 01 = 按键3触发场景
+                event.msgType = msgType;
+                event.sceneButton = frame[offset];      // 按键编号（1-6）
+                event.sceneState = frame[offset + 1];   // 状态（01=触发）
+                offset += 2;
+            } else {
+                // 未知消息类型，跳过1字节（假设参数长度为1）
+                offset++;
+            }
         }
 
         return event;

package/nodes/modbus-master.js

@@ -1180,7 +1180,7 @@ module.exports = function(RED) {
 
                 try {
                     if (task.type === 'single') {
-                        await node._writeSingleCoilInternal(task.slaveId, task.coil, task.value);
+                        await node._writeSingleCoilInternal(task.slaveId, task.coil, task.value, task.triggerSource);
                     } else if (task.type === 'multiple') {
                         await node._writeMultipleCoilsInternal(task.slaveId, task.startCoil, task.values);
                     }
@@ -1214,7 +1214,7 @@ module.exports = function(RED) {
         };
 
         // 写单个线圈（内部实现，不经过队列）
-        node._writeSingleCoilInternal = async function(slaveId, coil, value) {
+        node._writeSingleCoilInternal = async function(slaveId, coil, value, triggerSource = 'unknown') {
             if (!node.isConnected) {
                 throw new Error('Modbus未连接');
             }
@@ -1241,7 +1241,7 @@ module.exports = function(RED) {
                 node.client.setID(slaveId);
 
                 // 记录写入操作（帮助追踪总线数据来源）
-                node.log(`写入线圈: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                node.log(`写入线圈: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
 
                 await node.client.writeCoil(coil, value);
 
@@ -1269,7 +1269,8 @@ module.exports = function(RED) {
                         slave: slaveId,
                         coil: coil,
                         value: value,
-                        source: 'write'
+                        source: 'write',
+                        triggerSource: triggerSource  // 传递触发源标识
                     });
                 }
 
@@ -1300,7 +1301,7 @@ module.exports = function(RED) {
         };
 
         // 写单个线圈（公共接口，通过队列执行）
-        node.writeSingleCoil = function(slaveId, coil, value) {
+        node.writeSingleCoil = function(slaveId, coil, value, triggerSource = 'unknown') {
             return new Promise((resolve, reject) => {
                 // 添加到队列
                 node.writeQueue.push({
@@ -1308,6 +1309,7 @@ module.exports = function(RED) {
                     slaveId: slaveId,
                     coil: coil,
                     value: value,
+                    triggerSource: triggerSource,  // 传递触发源标识
                     resolve: resolve,
                     reject: reject
                 });
@@ -1431,13 +1433,14 @@ module.exports = function(RED) {
             const slave = parseInt(data.slave);
             const coil = parseInt(data.coil);
             const value = Boolean(data.value);
+            const triggerSource = data.triggerSource || 'unknown';  // 传递触发源标识
 
             // 输出日志确认收到事件
-            node.log(`收到内部事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+            node.log(`收到内部事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
 
             try {
                 // 执行写入操作（writeSingleCoil内部已经会广播状态变化事件）
-                await node.writeSingleCoil(slave, coil, value);
+                await node.writeSingleCoil(slave, coil, value, triggerSource);
 
                 node.log(`内部事件写入成功：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
             } catch (err) {

package/nodes/modbus-slave-switch.html

@@ -19,6 +19,7 @@
             meshShortAddress: {value: 0},  // Mesh设备短地址
             meshButtonNumber: {value: 1, validate: RED.validators.number()},  // Mesh按键编号（1-6）
             meshTotalButtons: {value: 1, validate: RED.validators.number()},  // Mesh开关总路数（1-6）
+            meshWirelessMode: {value: false},  // 无线模式（场景触发，不响应LED反馈）
             // 映射到继电器
             targetSlaveAddress: {value: 10, validate: RED.validators.number()},
             targetCoilNumber: {value: 1, validate: RED.validators.number()}  // 默认值改为1（显示为1路）
@@ -159,7 +160,8 @@
                                         btnSelect.empty();
                                         for (let i = 1; i <= device.buttons; i++) {
                                             const btnOption = $(`<option value="${i}">按钮 ${i}</option>`);
-                                            if (i === node.meshButtonNumber) {
+                                            // 修复：使用this.meshButtonNumber而不是node.meshButtonNumber
+                                            if (i === parseInt(node.meshButtonNumber)) {
                                                 btnOption.prop("selected", true);
                                             }
                                             btnSelect.append(btnOption);
@@ -329,7 +331,10 @@
             <option value="5">按钮 5</option>
             <option value="6">按钮 6</option>
         </select>
-        <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">Mesh开关按键（1-6路）</span>
+        <label style="margin-left: 15px; display: inline-block;">
+            <input type="checkbox" id="node-input-meshWirelessMode" style="width: auto; vertical-align: middle; margin: 0;">
+            <span style="vertical-align: middle; white-space: nowrap;">无线模式</span>
+        </label>
     </div>
 
     <input type="hidden" id="node-input-meshShortAddress">

package/nodes/modbus-slave-switch.js

@@ -13,6 +13,22 @@ module.exports = function(RED) {
     // 全局Mesh设备状态缓存（按短地址索引）
     // 用于同一个Mesh设备的多个按钮节点共享状态数组
     const meshDeviceStates = new Map();  // key: meshShortAddress, value: [state1, state2, ...]
+
+    // 全局Mesh无线模式按键标记（按短地址索引）
+    // 用于标记哪些按键是无线模式（场景触发，不响应LED反馈）
+    const meshWirelessButtons = new Map();  // key: meshShortAddress, value: Set([buttonNumber1, buttonNumber2, ...])
+
+
+
+    // 全局Mesh设备LED反馈防抖定时器（按短地址索引）
+    // 用于合并同一个Mesh设备的多个按钮状态变化，只发送一次LED反馈
+    const meshLedDebounceTimers = new Map();  // key: meshShortAddress, value: {timer, nodeId, serialPortConfig}
+
+    // 全局Mesh LED反馈批量发送队列
+    // 用于批量发送LED反馈，避免总线拥堵
+    const meshLedFeedbackQueue = [];  // [{meshAddr, states, timestamp}]
+    let meshLedFeedbackQueueTimer = null;
+    let meshLedFeedbackGlobalLock = 0;  // 全局锁定时间戳：在此时间之前，忽略所有Mesh面板的状态上报
     
     // 初始化Mesh设备持久化存储
     const meshPersistDir = path.join(RED.settings.userDir || os.homedir() + '/.node-red', 'mesh-devices-persist');
@@ -400,9 +416,9 @@ module.exports = function(RED) {
 
         // 节点关闭标志（用于静默关闭期间的警告）
         node.isClosing = false;
-
-        // 首次状态同步标志（用于识别部署/重启后的首次轮询）
-        node.hasReceivedInitialState = false;
+
+        // 首次状态同步标志（用于识别部署/重启后的首次轮询）
+        node.hasReceivedInitialState = false;
 
         // 根据按钮编号计算deviceAddr和channel（用于LED反馈）
         // Symi协议公式：按键编号 = deviceAddr * 4 - 4 + channel
@@ -493,16 +509,11 @@ module.exports = function(RED) {
         node.connectRs485 = async function() {
             try {
                 // 使用共享连接配置（由配置节点管理）
-                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;
-
-                // 立即结束初始化阶段（允许Mesh按键控制继电器）
-                // LED反馈已通过队列机制自动限速，无需延迟
-                node.isInitializing = false;
+
+                // 立即结束初始化阶段（允许Mesh按键控制继电器）
+                // LED反馈已通过队列机制自动限速，无需延迟
+                node.isInitializing = false;
                 node.updateStatus();
 
 
@@ -525,7 +536,12 @@ module.exports = function(RED) {
             if (node.serialPortConfig) {
                 // 定义数据监听器函数（静默处理，只在匹配时输出日志）
                 node.serialDataListener = (data) => {
-                    node.handleRs485Data(data);
+                    // 根据开关类型调用不同的处理函数
+                    if (node.config.switchType === 'mesh') {
+                        node.handleMeshData(data);
+                    } else {
+                        node.handleRs485Data(data);
+                    }
                 };
 
                 // 注册到共享连接配置
@@ -546,41 +562,166 @@ module.exports = function(RED) {
                 const slave = parseInt(data.slave);
                 const coil = parseInt(data.coil);
                 const value = Boolean(data.value);
+                const triggerSource = data.triggerSource || data.source || 'unknown';  // 触发源：'button-press', 'relay-control', 'init', 'unknown'
 
                 // 检查是否是我们关注的从站和线圈
-                // 识别首次轮询（source: 'init'），标记已接收初始状态
-                if (data.source === 'init' && !node.hasReceivedInitialState) {
-                    node.hasReceivedInitialState = true;
-                    node.debug(`收到首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
-                }
-
-                if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
-                    node.log(`收到状态变化事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                // 识别首次轮询（source: 'init'），标记已接收初始状态
+                if (data.source === 'init' && !node.hasReceivedInitialState) {
+                    node.hasReceivedInitialState = true;
+                    node.debug(`收到首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                }
+
+                // Mesh模式：监听所有绑定到同一个面板的线圈，更新全局状态缓存
+                if (node.config.buttonType === 'mesh' && slave === node.config.targetSlaveAddress) {
+                    const meshAddr = node.config.meshShortAddress;
+                    if (!meshDeviceStates.has(meshAddr)) {
+                        // 初始化状态数组（全部设为null，表示未知状态）
+                        meshDeviceStates.set(meshAddr, new Array(node.config.meshTotalButtons).fill(null));
+                    }
+
+                    // 计算线圈对应的按钮编号（线圈0→按钮1，线圈1→按钮2，...）
+                    const baseCoil = node.config.targetCoilNumber - (node.config.meshButtonNumber - 1);
+                    const buttonIndex = coil - baseCoil;
+
+                    // 检查是否是同一个面板的线圈（线圈范围：baseCoil ~ baseCoil+totalButtons-1）
+                    if (buttonIndex >= 0 && buttonIndex < node.config.meshTotalButtons) {
+                        // 更新全局状态缓存
+                        const states = meshDeviceStates.get(meshAddr);
+                        const oldValue = states[buttonIndex];
+                        states[buttonIndex] = value;
+                        const stateChanged = (oldValue !== value);
+
+                        // 核心修复：区分按键触发和继电器直接控制
+                        const isButtonPress = (triggerSource === 'button-press');
+                        const isInit = (triggerSource === 'init' || data.source === 'init');
+                        const isRelayControl = !isButtonPress && !isInit;
+
+                        // 继电器控制：所有同一面板的线圈变化都会重置定时器（只有按钮1节点负责）
+                        if (isRelayControl && stateChanged && node.config.meshButtonNumber === 1) {
+                            const now = Date.now();
+
+                            // 获取或创建定时器对象
+                            let timerObj = meshLedDebounceTimers.get(meshAddr);
+
+                            if (!timerObj) {
+                                // 首次变化：创建新的定时器对象
+                                timerObj = {
+                                    timer: null,
+                                    nodeId: node.id,
+                                    serialPortConfig: node.serialPortConfig,
+                                    firstChangeTime: now,  // 记录第一次变化的时间
+                                    changeCount: 0  // 记录变化次数
+                                };
+                                meshLedDebounceTimers.set(meshAddr, timerObj);
+                            }
+
+                            // 增加变化计数
+                            timerObj.changeCount++;
+
+                            // 清除之前的定时器
+                            if (timerObj.timer) {
+                                clearTimeout(timerObj.timer);
+                            }
+
+                            // 设置新的定时器：100ms内如果没有新的状态变化，才发送LED反馈
+                            const capturedNode = node;
+                            timerObj.timer = setTimeout(() => {
+                                // 检查是否是当前节点设置的定时器
+                                const currentTimerObj = meshLedDebounceTimers.get(meshAddr);
+                                if (currentTimerObj && currentTimerObj.nodeId === capturedNode.id) {
+                                    meshLedDebounceTimers.delete(meshAddr);
+                                    const currentStates = meshDeviceStates.get(meshAddr);
+
+                                    // 计算全局锁定时间：100ms（足够发送LED反馈，但不影响下一次按键）
+                                    const lockDuration = 100;
+                                    meshLedFeedbackGlobalLock = Date.now() + lockDuration;
+
+                                    // 发送LED反馈到物理开关面板（使用最新的完整状态）
+                                    const button1State = currentStates[0];  // 按钮1的状态
+                                    capturedNode.sendCommandToPanel(button1State);
+                                }
+                            }, 100);
+                        }
+
+                        // 只有当前节点绑定的线圈变化时，才更新节点状态并触发按键LED反馈
+                        if (coil === node.config.targetCoilNumber) {
+                            // 更新当前节点状态
+                            node.currentState = value;
+                            node.lastStateChange.timestamp = Date.now();
+                            node.lastStateChange.value = value;
+
+                            if (stateChanged) {
+                                if (isButtonPress) {
+                                    // 按键触发：立即发送整个面板LED状态（快速响应）
+                                    node.debug(`[LED反馈] Mesh${meshAddr} 按钮${node.config.meshButtonNumber}: 按键触发，立即发送整个面板LED状态`);
+
+                                    // 设置全局锁定：100ms内忽略所有Mesh面板的状态上报（缩短锁定时间，避免影响下一次按键）
+                                    meshLedFeedbackGlobalLock = Date.now() + 100;
+
+                                    // 立即发送LED反馈（整个面板）
+                                    node.sendCommandToPanel(value);
+                                } else if (isInit) {
+                                    // 首次轮询：发送LED反馈（同步初始状态）
+                                    // 使用防抖机制，避免重复发送
+                                    if (!meshLedDebounceTimers.has(meshAddr)) {
+                                        const capturedNode = node;
+                                        const timer = setTimeout(() => {
+                                            const timerObj = meshLedDebounceTimers.get(meshAddr);
+                                            if (timerObj && timerObj.nodeId === capturedNode.id) {
+                                                meshLedDebounceTimers.delete(meshAddr);
+                                                const currentStates = meshDeviceStates.get(meshAddr);
+                                                capturedNode.debug(`[LED反馈] Mesh${meshAddr} 首次轮询，发送整个面板LED状态: ${JSON.stringify(currentStates)}`);
+
+                                                // 设置全局锁定：100ms内忽略所有Mesh面板的状态上报
+                                                meshLedFeedbackGlobalLock = Date.now() + 100;
+
+                                                capturedNode.sendCommandToPanel(value);
+                                            }
+                                        }, 200);  // 200ms防抖时间，等待所有初始状态收集完毕
+
+                                        meshLedDebounceTimers.set(meshAddr, {
+                                            timer: timer,
+                                            nodeId: node.id,
+                                            serialPortConfig: node.serialPortConfig
+                                        });
+
+                                        node.debug(`[LED防抖] Mesh${meshAddr} 按钮${node.config.meshButtonNumber}: 首次轮询，设置防抖定时器(200ms)`);
+                                    }
+                                }
+                            }
+
+                            // 更新节点状态显示
+                            node.updateStatus();
+
+                            // 输出状态消息（立即输出，不等待防抖）
+                            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
+                            });
+                        }
+                    }
+                } else if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
+                    // RS-485模式或非Mesh模式：只处理自己绑定的线圈
+                    // 检查状态是否真正变化
+                    const stateChanged = (node.currentState !== value);
 
                     // 更新当前状态
                     node.currentState = value;
                     node.lastStateChange.timestamp = Date.now();
                     node.lastStateChange.value = value;
 
-                    // Mesh模式：更新全局共享状态缓存（用于构建正确的控制帧）
-                    if (node.config.buttonType === 'mesh') {
-                        const meshAddr = node.config.meshShortAddress;
-                        if (!meshDeviceStates.has(meshAddr)) {
-                            // 初始化状态数组（全部设为null，表示未知状态）
-                            meshDeviceStates.set(meshAddr, new Array(node.config.meshTotalButtons).fill(null));
-                        }
-                        // 更新对应按钮的状态
-                        const states = meshDeviceStates.get(meshAddr);
-                        states[node.config.meshButtonNumber - 1] = value;
-                        node.debug(`[Mesh状态更新] 设备${meshAddr} 按钮${node.config.meshButtonNumber} = ${value}, 完整状态=${JSON.stringify(states)}`);
+                    if (stateChanged) {
+                        // RS-485模式：立即发送LED反馈（不需要防抖）
+                        node.sendCommandToPanel(value);
                     }
 
                     // 更新节点状态显示
                     node.updateStatus();
 
-                    // 发送LED反馈到物理开关面板
-                    node.sendCommandToPanel(value);
-
                     // 输出状态消息
                     node.send({
                         payload: value,
@@ -595,7 +736,6 @@ module.exports = function(RED) {
 
             // 注册内部事件监听器
             RED.events.on('modbus:coilStateChanged', node.stateChangeListener);
-            node.log('已注册状态变化监听器（用于LED反馈）');
         };
 
         // 处理RS-485接收到的数据
@@ -697,36 +837,98 @@ module.exports = function(RED) {
                 }
 
                 // 检查消息类型
-                if (event.msgType !== meshProtocol.PROTOCOL.MSG_TYPE_SWITCH &&
-                    event.msgType !== meshProtocol.PROTOCOL.MSG_TYPE_SWITCH_6) {
-                    return; // 不是开关状态，忽略
-                }
+                let isSceneMode = false;
+                let buttonState = null;
 
-                // 获取按钮状态
-                if (!event.states || event.states.length < node.config.meshButtonNumber) {
-                    return; // 状态数据不完整
-                }
+                if (event.msgType === meshProtocol.PROTOCOL.MSG_TYPE_SCENE) {
+                    // 场景模式（无线开关）：触发继电器控制，但不响应LED反馈
+                    if (event.sceneButton !== node.config.meshButtonNumber) {
+                        return; // 不是我们的按键，忽略
+                    }
+                    isSceneMode = true;
+
+                    // 场景模式：每次触发都翻转状态（点动模式）
+                    buttonState = !node.currentState;
+                    node.debug(`[Mesh场景] 设备${event.shortAddr} 按键${event.sceneButton} 触发场景，翻转状态为${buttonState}`);
+                } else if (event.msgType === meshProtocol.PROTOCOL.MSG_TYPE_SWITCH ||
+                           event.msgType === meshProtocol.PROTOCOL.MSG_TYPE_SWITCH_6) {
+                    // 开关模式：正常处理状态
+                    // 获取按钮状态
+                    if (!event.states || event.states.length < node.config.meshButtonNumber) {
+                        node.warn(`[Mesh事件] 按键${node.config.meshButtonNumber} 状态数据不完整，states=${JSON.stringify(event.states)}`);
+                        return; // 状态数据不完整
+                    }
 
-                const buttonState = event.states[node.config.meshButtonNumber - 1];
-                if (buttonState === null) {
-                    return; // 状态未知，忽略
+                    buttonState = event.states[node.config.meshButtonNumber - 1];
+                    if (buttonState === null) {
+                        return; // 状态未知，忽略
+                    }
+                } else {
+                    return; // 不是开关或场景消息，忽略
                 }
 
-                // 全局防抖：防止多个节点重复处理同一个按键
-                const debounceKey = `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
-                const now = Date.now();
-                const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+                const meshAddr = node.config.meshShortAddress;
+                let now = Date.now();
 
-                // 全局防抖：200ms内只触发一次
-                if (now - lastTriggerTime < 200) {
-                    return; // 静默忽略重复触发
-                }
-                globalDebounceCache.set(debounceKey, now);
+                // 场景模式：跳过LED反馈锁和状态缓存检查，直接触发继电器
+                if (isSceneMode) {
+                    // 场景模式：全局防抖（200ms内只触发一次）
+                    const debounceKey = `mesh-scene-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
+                    const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
-                // 更新全局共享状态缓存（用于后续控制时保持其他路不变）
-                const meshAddr = node.config.meshShortAddress;
-                meshDeviceStates.set(meshAddr, event.states);
-                node.debug(`[Mesh按键] 设备${meshAddr} 状态更新=${JSON.stringify(event.states)}`);
+                    if (now - lastTriggerTime < 200) {
+                        node.debug(`[Mesh场景] 全局防抖忽略：设备${meshAddr} 按键${node.config.meshButtonNumber} (${now - lastTriggerTime}ms内)`);
+                        return;
+                    }
+                    globalDebounceCache.set(debounceKey, now);
+
+                    node.debug(`[Mesh场景] 设备${meshAddr} 按键${node.config.meshButtonNumber} 触发继电器控制: ${buttonState}`);
+
+                    // 跳过后续的状态缓存检查，直接发送继电器控制命令
+                } else {
+                    // 开关模式：正常处理LED反馈锁和状态缓存
+
+                    // 第一步：检查全局LED反馈锁（最高优先级）
+                    // 在批量LED反馈发送期间，忽略所有Mesh面板的状态上报
+                    if (now < meshLedFeedbackGlobalLock) {
+                        // 静默忽略：LED反馈批量发送期间的状态上报
+                        return;
+                    }
+
+                    // 第二步：获取或初始化全局共享状态缓存
+                    if (!meshDeviceStates.has(meshAddr)) {
+                        // 第一次收到状态，初始化为全null数组
+                        meshDeviceStates.set(meshAddr, new Array(event.states.length).fill(null));
+                    }
+                    const previousStates = meshDeviceStates.get(meshAddr);
+                    const previousButtonState = previousStates[node.config.meshButtonNumber - 1];
+
+                    // 第三步：检查当前按键状态是否变化（关键：防止所有节点都被触发）
+                    const buttonStateChanged = (previousButtonState !== buttonState);
+
+                    if (!buttonStateChanged) {
+                        // 状态未变化，忽略（这样可以避免所有节点都被触发）
+                        node.debug(`[Mesh事件] 按键${node.config.meshButtonNumber}状态未变化(${buttonState})，忽略`);
+                        return;
+                    }
+
+                    // 第四步：全局防抖：防止多个节点重复处理同一个按键
+                    const debounceKey = `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
+                    now = Date.now();
+                    const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+
+                    // 全局防抖：200ms内只触发一次
+                    if (now - lastTriggerTime < 200) {
+                        node.debug(`[Mesh事件] 全局防抖忽略：设备${meshAddr} 按键${node.config.meshButtonNumber} (${now - lastTriggerTime}ms内)`);
+                        return; // 静默忽略重复触发
+                    }
+                    globalDebounceCache.set(debounceKey, now);
+
+                    // 第五步：更新全局共享状态缓存（只更新当前按键的状态）
+                    previousStates[node.config.meshButtonNumber - 1] = buttonState;
+                    meshDeviceStates.set(meshAddr, previousStates);
+                    node.debug(`[Mesh按键] 设备${meshAddr} 按键${node.config.meshButtonNumber} 状态变化: ${previousButtonState} → ${buttonState}`);
+                }
 
                 // 初始化期间不发送控制命令（避免重启时Mesh开关状态覆盖继电器状态）
                 if (node.isInitializing) {
@@ -740,8 +942,9 @@ module.exports = function(RED) {
                 }
 
                 // 发送命令到继电器
-                node.debug(`Mesh开关${buttonState ? 'ON' : 'OFF'}: MAC=${node.config.meshMacAddress} 按键${node.config.meshButtonNumber}`);
-                node.sendMqttCommand(buttonState);
+                const modeLabel = isSceneMode ? 'Mesh场景' : 'Mesh按键';
+                node.debug(`[${modeLabel}] 发送命令到继电器：从站${node.config.targetSlaveAddress} 线圈${node.config.targetCoilNumber} = ${buttonState ? 'ON' : 'OFF'}`);
+                node.sendMqttCommand(buttonState, isSceneMode);
 
             } catch (err) {
                 node.error(`解析Mesh数据失败: ${err.message}`);
@@ -749,7 +952,7 @@ module.exports = function(RED) {
         };
 
         // 发送命令到继电器（支持两种模式：MQTT模式和内部事件模式）
-        node.sendMqttCommand = function(state) {
+        node.sendMqttCommand = function(state, isSceneMode = false) {
             // 模式1：MQTT模式（通过MQTT发送命令，由主站节点统一处理）
             if (node.config.enableMqtt && node.mqttClient && node.mqttClient.connected) {
                 // 直接发送MQTT命令（不使用队列，立即发送）
@@ -775,11 +978,11 @@ module.exports = function(RED) {
                 coil: node.config.targetCoilNumber,
                 value: state,
                 source: 'slave-switch',
+                triggerSource: isSceneMode ? 'scene-trigger' : 'button-press',  // 场景模式使用scene-trigger，开关模式使用button-press
                 nodeId: node.id
             });
 
-            // 输出日志确认发送
-            node.log(`内部事件模式：发送命令到从站${node.config.targetSlaveAddress} 线圈${node.config.targetCoilNumber} = ${state ? 'ON' : 'OFF'}`);
+            // 内部事件模式：静默发送（不输出日志）
         };
         
         // 处理命令队列（防止多个按键同时按下造成冲突）
@@ -847,22 +1050,12 @@ module.exports = function(RED) {
                 return;
             }
 
-            // 智能LED反馈控制：首次轮询时允许发送，通过队列自动限速
-            // 移除固定5秒延迟，部署/重启后立即同步LED状态（1秒内完成）
-            // 队列机制已有40ms间隔，不会造成总线拥堵
+            // 智能LED反馈控制：首次轮询时允许发送，通过队列自动限速
+            // 移除固定5秒延迟，部署/重启后立即同步LED状态（1秒内完成）
+            // 队列机制已有40ms间隔，不会造成总线拥堵
 
             const now = Date.now();
 
-            // 防止重复发送：如果状态相同且时间间隔小于50ms，跳过
-            if (node.lastSentLedState.value === state && (now - node.lastSentLedState.timestamp) < 50) {
-                node.debug(`跳过重复LED反馈（状态未变化，间隔${now - node.lastSentLedState.timestamp}ms）`);
-                return;
-            }
-
-            // 更新最后发送状态
-            node.lastSentLedState.value = state;
-            node.lastSentLedState.timestamp = now;
-
             // 构建LED反馈协议帧
             let command;
 
@@ -870,9 +1063,40 @@ module.exports = function(RED) {
                 // Mesh模式：发送Mesh控制帧
                 // 从全局共享状态中获取当前设备的完整状态
                 const meshAddr = node.config.meshShortAddress;
-                const currentStates = meshDeviceStates.get(meshAddr) || null;
+                let currentStates = meshDeviceStates.get(meshAddr) || null;
+
+                // 无线模式过滤：将null状态和无线模式按键的LED状态强制设为OFF
+                // 复制状态数组，避免修改全局状态
+                if (currentStates) {
+                    const wirelessButtons = meshWirelessButtons.get(meshAddr);
+                    node.debug(`[无线模式检查] 设备${meshAddr} 无线按键=${wirelessButtons ? Array.from(wirelessButtons) : '无'}`);
+                    currentStates = currentStates.map((s, idx) => {
+                        // null状态强制设为false
+                        if (s === null) return false;
+                        // 无线模式按键强制设为false（不响应LED反馈）
+                        const buttonNum = idx + 1;
+                        if (wirelessButtons && wirelessButtons.has(buttonNum)) {
+                            node.debug(`[无线模式过滤] 按键${buttonNum} LED强制设为OFF`);
+                            return false;
+                        }
+                        return s;
+                    });
+                    node.debug(`[LED反馈] 过滤后状态=${JSON.stringify(currentStates)}`);
+                }
+
+                // 防止重复发送：比较完整状态数组，如果相同且时间间隔小于50ms，跳过
+                const statesStr = JSON.stringify(currentStates);
+                if (node.lastSentLedState.statesStr === statesStr && (now - node.lastSentLedState.timestamp) < 50) {
+                    node.debug(`跳过重复LED反馈（状态未变化，间隔${now - node.lastSentLedState.timestamp}ms）`);
+                    return;
+                }
 
-                node.debug(`[Mesh LED] 准备发送：设备${meshAddr} 按钮${node.config.meshButtonNumber} = ${state}, 当前状态=${JSON.stringify(currentStates)}`);
+                // 更新最后发送状态
+                node.lastSentLedState.value = state;
+                node.lastSentLedState.statesStr = statesStr;
+                node.lastSentLedState.timestamp = now;
+
+                node.debug(`[Mesh LED发送] 设备${meshAddr} 按钮${node.config.meshButtonNumber} = ${state}, 完整状态=${JSON.stringify(currentStates)}`);
 
                 command = meshProtocol.buildSwitchControlFrame(
                     node.config.meshShortAddress,
@@ -923,15 +1147,7 @@ module.exports = function(RED) {
                 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}]`);
-                    }
+                    // LED反馈发送成功（静默，不输出日志）
                 }
             }, priority, switchId);
         };
@@ -981,8 +1197,6 @@ module.exports = function(RED) {
         node.connectMqtt = function() {
             // 检查是否启用MQTT
             if (!node.config.enableMqtt) {
-                node.log('MQTT未启用 - 使用内部事件模式（免连线通信）');
-                node.log('提示：物理开关面板按键会通过内部事件自动发送到主站节点');
                 return;
             }
             
@@ -1032,12 +1246,6 @@ module.exports = function(RED) {
                     
                     node.mqttClient.on('connect', () => {
                         node.mqttConnected = true;
-                        node.log(`MQTT已连接: ${brokerUrl}`);
-                        
-                        // 成功连接后，更新配置的broker地址（下次优先使用成功的地址）
-                        if (brokerUrl !== brokerCandidates[0]) {
-                            node.debug(`使用fallback地址成功: ${brokerUrl}（原配置: ${brokerCandidates[0]}）`);
-                        }
                         
                         node.updateStatus();
                         
@@ -1045,8 +1253,6 @@ module.exports = function(RED) {
                         node.mqttClient.subscribe(node.stateTopic, { qos: 1 }, (err) => {
                             if (err) {
                                 node.error(`订阅失败: ${err.message}`);
-                            } else {
-                                node.log(`已订阅: ${node.stateTopic}（QoS=1）`);
                             }
                         });
                     });
@@ -1238,8 +1444,6 @@ module.exports = function(RED) {
                 node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
                     if (err) {
                         node.error(`发布命令失败: ${err.message}`);
-                    } else {
-                        node.log(`发送命令: ${command} 到 ${node.commandTopic}`);
                     }
                 });
             } else {
@@ -1254,13 +1458,22 @@ module.exports = function(RED) {
         // 节点关闭时清理
         node.on('close', function(done) {
             node.isClosing = true;
-            
+
             // 清除重连定时器
             if (node.reconnectTimer) {
                 clearTimeout(node.reconnectTimer);
                 node.reconnectTimer = null;
             }
-            
+
+            // 清除全局Mesh LED防抖定时器（如果是Mesh模式）
+            if (node.config.buttonType === 'mesh') {
+                const meshAddr = node.config.meshShortAddress;
+                if (meshLedDebounceTimers.has(meshAddr)) {
+                    clearTimeout(meshLedDebounceTimers.get(meshAddr).timer);
+                    meshLedDebounceTimers.delete(meshAddr);
+                }
+            }
+
             // 清理队列（释放内存）
             node.commandQueue = [];
             node.frameBuffer = Buffer.alloc(0);
@@ -1269,7 +1482,6 @@ module.exports = function(RED) {
             if (node.serialPortConfig && node.serialDataListener) {
                 try {
                     node.serialPortConfig.unregisterDataListener(node.serialDataListener);
-                    node.log('RS-485数据监听器已注销');
                 } catch (err) {
                     node.warn(`注销RS-485监听器时出错: ${err.message}`);
                 }
@@ -1280,7 +1492,6 @@ module.exports = function(RED) {
             if (node.stateChangeListener) {
                 RED.events.removeListener('modbus:coilStateChanged', node.stateChangeListener);
                 node.stateChangeListener = null;
-                node.log('状态变化监听器已移除');
             }
             
             // 关闭MQTT连接
@@ -1290,7 +1501,6 @@ module.exports = function(RED) {
                         // 移除所有监听器（防止内存泄漏）
                         node.mqttClient.removeAllListeners();
                         node.mqttClient.end(false, () => {
-                            node.log('MQTT连接已关闭');
                             node.mqttClient = null;
                             node.mqttConnected = false;
                             done();
@@ -1313,6 +1523,16 @@ module.exports = function(RED) {
         });
         
         // 初始化
+        // 如果是Mesh无线模式，注册到全局Map
+        if (node.config.buttonType === 'mesh' && node.config.meshWirelessMode === true) {
+            const meshAddr = node.config.meshShortAddress;
+            if (!meshWirelessButtons.has(meshAddr)) {
+                meshWirelessButtons.set(meshAddr, new Set());
+            }
+            meshWirelessButtons.get(meshAddr).add(node.config.meshButtonNumber);
+            node.log(`[无线模式] 注册按键：设备${meshAddr} 按键${node.config.meshButtonNumber}`);
+        }
+
         node.updateStatus();
         node.connectRs485();  // 连接RS-485总线
         node.connectMqtt();   // 连接MQTT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.8.8",
+  "version": "2.8.9",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {