node-red-contrib-symi-modbus 2.10.3 → 2.10.6

package/README.md

@@ -32,6 +32,9 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
   - **门禁联动过滤**：继电器节点支持门禁ID过滤，实现精确的门禁联动控制
   - **HomeKit网桥**：一键接入Apple HomeKit，支持Siri语音控制，状态实时同步
   - **智能写入队列**：所有写入操作串行执行，支持优先级管理，确保指示灯反馈在群控场景下秒级响应
+  - **多主站精准隔离**：支持多主站并行运行，通过 `masterId` 实现指令精准定向，严格过滤跨主站事件，彻底解决多主站环境下的控制冲突与误触发
+  - **智能反馈路由**：从站开关节点自动识别所属主站，仅响应目标主站的状态变化，防止多系统并存时的信号串扰
+  - **真·状态翻转逻辑**：继电器输出节点内置状态感知能力，基于物理设备真实反馈执行翻转操作，解决传统盲发指令导致的开关失灵
 - **可视化运维**：
   - **控制看板**：实时显示所有继电器状态，支持手动控制
   - **调试模式**：详细的通信日志，支持十六进制报文监控
@@ -280,6 +283,7 @@ node-red-restart
    - 轮询恢复时间：50ms（写入完成后快速恢复轮询）
    - 锁等待超时：500ms（适配高延迟网络，确保指令不丢失）
    - 智能优先队列：触发源面板优先处理（500ms优先窗口）
+   - 触发源追踪：全链路追踪控制指令来源（triggerSource），日志清晰记录是物理按键、HomeKit还是自动化触发
    - 队列自动处理，无需手动干预
 
 ## 核心特性说明
@@ -957,6 +961,27 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本更新说明
 
+### v2.10.6 (2026-01-17)
+- **多节点LED状态聚合**: 支持多个 `从站开关` 节点配置为同一物理按键（相同 Switch ID 和 Button ID）但控制不同继电器。系统会自动聚合所有关联继电器的状态（OR逻辑），实现“任意开则灯亮，全关则灯灭”的智能反馈，完美支持“一键多控”场景。
+- **Clowire协议深度优化**: 新增支持 Clowire 协议的“全关”指令（0x1020=0x0002）。当检测到某面板下的所有按键状态均为 OFF 时，系统会自动合并发送一条全关指令，替代逐个发送的关闭指令，大幅降低 RS-485 总线通信压力，提升批量关灯时的响应速度。
+- **Symi协议深度优化**: 新增支持 Symi 协议的“全关”指令（0x05 MULTI）。逻辑同上，当检测到 Symi 面板所有按键全关时，自动发送一条多灯控制指令（状态位全0），实现高效的“一键全关”反馈。
+- **网络错误日志优化**: 对 Modbus 主站的 TCP/串口底层连接错误进行严格限流（每分钟仅记录一次），避免在网络不稳定或断网情况下产生大量垃圾日志，保护磁盘空间。
+- **稳定性增强**: 优化了全局状态管理的内存回收机制，确保节点删除或重部署时无内存残留。
+
+### v2.10.5 (2026-01-15)
+- **多主站精准隔离架构**：引入 `masterId` 指令定向机制。`relay-output` 节点现在可以精准锁定目标主站，彻底解决了多主站环境下（如多台 Modbus 网关）指令错发或“一控多”的冲突问题。
+- **真·状态翻转 (Toggle) 逻辑**：继电器输出节点新增状态感知能力。通过实时监听总线状态回传（Coil State Sync），翻转动作不再是盲目的逻辑取反，而是基于物理设备真实状态的精准操作，解决了高频连点或多端控制下的状态不同步顽疾。
+- **指示灯反馈机制重构**：优化了 `modbus-slave-switch` 的反馈锁与初始化逻辑。移除了过度的初始化过滤，确保面板指示灯在系统重启或状态突变时能秒级同步（包括 OFF 状态），解决了指示灯反馈“只开不关”的问题。
+- **生产级日志分级**：对全局日志进行了分级处理。将底层的 Modbus 通信报文转入 Debug 级别，控制台仅保留关键的业务联动日志（如 `[免连线联动]`），极大提升了高并发场景下的运行效率并降低了 IO 损耗。
+- **资源管理与稳定性**：规范化了所有节点的 `close` 生命周期管理。完善了事件监听器的移除机制，确保在频繁部署或节点增删时内存无泄露，系统长期运行更加稳健。
+
+### v2.10.4 (2026-01-14)
+- **Modbus超时优化**：将默认Modbus通信超时时间（Timeout）统一调整为 **3000ms**（原TCP 1000ms/串口 2000ms），彻底解决网络波动或从站响应慢导致的“轮询超时”和“写入失败”问题，这是生产环境稳定的关键参数。
+- **锁等待恢复合理值**：将写入锁等待超时恢复为 **3000ms**，配合更长的底层通信超时，确保在总线繁忙时依然能有序排队，不再出现死锁或虚假超时。
+- **断连彻底静默**：移除写入队列在断连时的错误日志提醒，断线期间不报错、不刷屏，确保生产环境日志整洁。
+- **缓存策略优化**：连接断开时立即清空所有待处理的写入任务（`writeQueue = []`），重连后不处理断连期间的旧指令，只响应重连后的新操作。
+- **连接恢复优化**：移除重连后的自动任务恢复逻辑，实现真正的“断连不处理缓存，重连只理新数”。
+
 ### v2.10.3 (2026-01-14)
 - **协议兼容性**: 完善 Symi 协议解析逻辑，全面支持 `0x03 SET`、`0x04 REPORT` 和 `0x05 STATUS` 帧类型，解决某些面板状态错位导致的按键不响应问题。
 - **稳定性修复**: 紧急修复物理回显导致的“继电器无限跳动”死循环问题，通过严格过滤 `0x04` 反馈帧并延长反馈锁至 **100ms**，确保系统在复杂干扰环境下依然稳定。
@@ -978,17 +1003,6 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - **防抖优化**: 引入全局按键事件去重防抖，解决信号抖动问题。
 - **组网支持**: 改进 LED 反馈机制，支持 Symi/Clowire/Mesh 多品牌混合组网下的状态同步。
 
-### v2.9.20 (2026-01-12)
-- **协议同步**: RS-485 开关指示灯同步逻辑，严格遵循协议规范（SET 0x03/REPORT 0x04）。
-- **优先队列**: 为 LED 反馈指令引入独立的高优先级队列，确保高负载下指示灯秒级同步。
-- **映射修正**: 修正 `buttonNumber` 类型转换，解决 8 键面板通道映射偏移问题。
-
-### v2.9.14 (2025-12-30)
-- **新协议**: 支持 Clowire（克伦威尔）智能面板协议。
-- **新节点**: 继电器输出节点（relay-output），支持通过内部事件直接绑定从站开关。
-- **环境适配**: 优化 HassOS 环境下的串口锁定问题（lock: false）。
-
-
 **核心特性**：
 - **指示灯同步逻辑优化**：
   - **485面板**：使用 `REPORT (0x04)` 协议进行反馈，并将主机地址固定为 `0x00`，确保同步状态时不触发继电器动作。
@@ -1013,6 +1027,13 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - **多连接支持**：支持 Mac/Linux 多串口与 TCP 同时运行，各主站实例完全隔离，互不干扰。
 - **断电恢复**：所有状态和配置自动持久化，设备上电后 1 秒内自动同步最新状态。
 - **日志防护**：错误日志限流与磁盘溢出保护，确保工控机环境下的系统安全。
+- **日志分级**：生产环境下仅输出关键业务日志，详细通信日志转入 Debug 级别
+- **智能优先队列**：触发源面板优先处理（500ms优先窗口）
+  - **队列自动处理**：指令自动串行化，避免 RS485 总线冲突
+  - **断连自动恢复**：主站/从站连接断开后支持毫秒级自动重连
+  - **多实例运行**：支持同时运行多个 `Modbus主站` 节点，配置完全隔离
+  - **状态持久化**：Mesh 设备列表和继电器状态在重启后自动恢复
+  - **日志分级**：生产环境下仅输出关键业务日志，详细通信日志转入 Debug 级别
 
 **实际使用场景**：
 - 主站轮询：200ms/台，支持5-10台从站设备

package/nodes/clowire-protocol.js

@@ -193,6 +193,30 @@ module.exports = {
         return buffer;
     },
     
+    /**
+     * 构建关闭所有LED指示灯指令（写入0x1020值为0x0002）
+     * @param {number} panelAddr - 面板地址（1-127）
+     * @returns {Buffer} 完整的指令帧
+     */
+    buildTurnOffAllLedsCommand: function(panelAddr) {
+        const buffer = Buffer.alloc(9);
+        let idx = 0;
+        
+        buffer[idx++] = panelAddr;
+        buffer[idx++] = this.CMD_WRITE;
+        buffer[idx++] = 0x10;  // 寄存器地址高字节
+        buffer[idx++] = 0x20;  // 寄存器地址低字节（0x1020）
+        buffer[idx++] = 0x00;
+        buffer[idx++] = 0x02;  // 值 0x0002 表示关闭所有LED
+        
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[idx++] = crc & 0xFF;
+        buffer[idx++] = (crc >> 8) & 0xFF;
+        buffer[idx++] = this.FRAME_TAIL;
+        
+        return buffer;
+    },
+
     /**
      * 判断是否是有效的 Clowire 协议帧
      * @param {Buffer} buffer - 接收到的数据

package/nodes/lightweight-protocol.js

@@ -165,6 +165,41 @@ module.exports = {
         
         return buffer;
     },
+
+    /**
+     * 构建多灯状态反馈指令（REPORT类型，用于状态同步到面板指示灯）
+     * 用于“全关”等批量操作优化
+     * @param {number} localAddr - 本机地址
+     * @param {number} deviceAddr - 设备地址
+     * @param {number} states - 灯状态位图（8bit，每bit对应1个灯）
+     * @returns {Buffer} 完整的指令帧
+     */
+    buildMultiLightReport: function(localAddr, deviceAddr, states) {
+        const buffer = Buffer.alloc(16);
+        let idx = 0;
+        
+        buffer[idx++] = this.FRAME_HEADER;      // 帧头
+        buffer[idx++] = localAddr;              // 本机地址
+        buffer[idx++] = this.DATA_TYPE_REPORT;  // 数据类型：上报（用于反馈）
+        buffer[idx++] = 0x10;                   // 数据长度
+        buffer[idx++] = this.DEVICE_TYPE_LIGHT; // 设备类型：灯光
+        buffer[idx++] = 0x00;                   // 品牌ID
+        buffer[idx++] = deviceAddr;             // 设备地址
+        buffer[idx++] = 0x00;                   // 设备通道（多灯控制通常为0）
+        buffer[idx++] = 0x00;                   // 房间号
+        buffer[idx++] = 0x00;                   // 房间类型
+        buffer[idx++] = 0x00;                   // 房间ID
+        buffer[idx++] = this.LIGHT_OP_MULTI;    // 操作码：多灯控制
+        buffer[idx++] = 0x00;                   // 延时（反馈不需要延时）
+        buffer[idx++] = states;                 // 灯状态位图
+        
+        // 计算CRC8校验
+        const crc = this.calculateCRC8(buffer, 16);
+        buffer[idx++] = crc;                    // CRC8校验
+        buffer[idx++] = this.FRAME_TAIL;        // 报尾
+        
+        return buffer;
+    },
     
     /**
      * 构建查询指令

package/nodes/modbus-master.js

@@ -161,11 +161,16 @@ module.exports = function(RED) {
         node.pausePolling = false; // 暂停轮询标志（从站上报时暂停）
         node.pollingPausedCount = 0; // 暂停轮询计数器
         node._discoveryPublished = false; // Discovery发布标志（避免重复）
+        node.lastSocketErrorTime = 0; // socket错误日志时间
 
         // 写入队列机制（确保所有写入操作串行执行，避免锁竞争）
         node.writeQueue = []; // 写入队列
         node.isProcessingWrite = false; // 是否正在处理写入队列
-        node.writeQueueInterval = 50; // 写入队列处理间隔（50ms，厂家推荐间隔，确保总线稳定）
+        node.writeQueueInterval = 50; // 写入队列处理间隔（恢复为50ms，确保多设备控制响应速度）
+
+        // 新增：命令去重缓存（防止短时间内重复发送相同指令）
+        node.commandCache = new Map();
+        node.commandCacheTimeout = 500; // 500ms内相同的指令视为重复
 
         // 注册到全局主站实例表（用于调试和监控）
         masterInstances.set(node.masterId, {
@@ -329,23 +334,35 @@ module.exports = function(RED) {
                 }
 
                 // 设置Modbus超时时间
-                // TCP模式：降低到1000ms，避免一个主站超时阻塞其他主站太久
-                // 串口模式：保持2000ms，串口通信需要更长时间
-                const timeout = node.config.connectionType === "serial" ? 2000 : 1000;
+                // TCP模式：提高到3000ms，适配网络波动较大的环境
+                // 串口模式：提高到3000ms，串口通信在复杂环境下需要更长时间
+                const timeout = 3000;
                 node.client.setTimeout(timeout);
                 node.log(`Modbus超时设置: ${timeout}ms`);
 
                 // 设置错误处理器，防止未捕获的错误导致进程崩溃
                 if (node.client._port) {
                     node.client._port.on('error', (err) => {
-                        node.log(`串口错误（已忽略）: ${err.message}`);
+                        const now = Date.now();
+                        if (now - (node.lastSocketErrorTime || 0) > 60000) { // 1分钟限流
+                             node.log(`串口错误（已忽略）: ${err.message}`);
+                             node.lastSocketErrorTime = now;
+                        } else {
+                             node.debug(`串口错误（已忽略）: ${err.message}`);
+                        }
                     });
                 }
 
                 // TCP模式：设置socket错误处理器
                 if (node.client._client) {
                     node.client._client.on('error', (err) => {
-                        node.log(`TCP socket错误（已忽略）: ${err.message}`);
+                        const now = Date.now();
+                        if (now - (node.lastSocketErrorTime || 0) > 60000) { // 1分钟限流
+                             node.log(`TCP socket错误（已忽略）: ${err.message}`);
+                             node.lastSocketErrorTime = now;
+                        } else {
+                             node.debug(`TCP socket错误（已忽略）: ${err.message}`);
+                        }
                     });
                 }
                 
@@ -382,8 +399,15 @@ module.exports = function(RED) {
                     node.log('轮询已在运行中');
                 }
 
+                // 恢复处理写入队列（如果有积压的任务）
+                if (node.writeQueue.length > 0) {
+                    node.log(`连接恢复，继续处理 ${node.writeQueue.length} 个积压的写入任务`);
+                    node.processWriteQueue();
+                }
+
             } catch (err) {
                 node.isConnected = false;
+                // 注意：不要清空 writeQueue，让任务在重连后继续尝试
                 
                 // 优化：如果错误消息没有变化，且不是第一次重试，则不输出 node.error 到全局日志
                 // 这样可以避免 ECONNREFUSED 等持续性错误刷屏
@@ -901,17 +925,12 @@ module.exports = function(RED) {
 
             const coilCount = slave.coilEnd - slave.coilStart + 1;
 
-            // 检查是否刚写入过（写入后50ms内不轮询该从站，避免读到旧值）
-            const lastWrite = node.lastWriteTime[slaveId] || 0;
-            const timeSinceWrite = Date.now() - lastWrite;
-            if (timeSinceWrite < 50) {
-                // 跳过该从站（不移动索引，由pollLoop统一管理）
-                return;
-            }
-
-                // 检查锁状态（如果有写操作正在进行，或者写入队列不为空，跳过本次轮询，优先让出总线）
-                if (node.modbusLock || node.writeQueue.length > 0 || node.isProcessingWrite) {
-                    // 跳过该从站（不移动索引，由pollLoop统一管理）
+                // 检查是否刚写入过（写入后50ms内不轮询该从站，避免读到旧值）
+                const lastWrite = node.lastWriteTime[slaveId] || 0;
+                const timeSinceWrite = Date.now() - lastWrite;
+                if (timeSinceWrite < 50) {
+                    // 跳过该从站，但必须移动索引，否则会死锁在当前从站
+                    node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
                     return;
                 }
 
@@ -1069,6 +1088,7 @@ module.exports = function(RED) {
                     }
 
                     node.isConnected = false;
+                    node.writeQueue = []; // 断开连接时清空写入队列，不处理缓存数据
                     // 原则：轮询永不停止，即使连接断开也由 startPolling 的 pollLoop 自动重试
                     // 不再调用 node.stopPolling()，避免轮询线程彻底终止
                     // node.stopPolling();
@@ -1209,14 +1229,16 @@ module.exports = function(RED) {
                     // 统一使用 REPORT (0x04) 作为应答，避免 SET (0x03) 触发面板继电器动作
                     // 仅在 buttonEvent.needFeedback 为 true 时发送，开关模式通常不需要反馈
                     if (buttonEvent.needFeedback) {
-                        const responseFrame = protocol.buildSingleLightReport(0x01, deviceAddr, channel, state);
+                        // 禁用 Master 的自动反馈，避免与 modbus-slave-switch 冲突
+                        // const responseFrame = protocol.buildSingleLightReport(0x01, deviceAddr, channel, state);
 
                         // 通过 writeRaw 进入写入队列，实现非阻塞和串行化
-                        node.writeRaw(responseFrame).then(() => {
-                            node.debug(`Symi应答已发送(REPORT): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
-                        }).catch(err => {
-                            node.log(`Symi应答发送失败: ${err.message}`);
-                        });
+                        // node.writeRaw(responseFrame).then(() => {
+                        //     node.debug(`Symi应答已发送(REPORT): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                        // }).catch(err => {
+                        //     node.log(`Symi应答发送失败: ${err.message}`);
+                        // });
+                        node.debug(`Symi按键事件(Master忽略反馈): 设备${deviceAddr} 通道${channel}，交由从站开关节点处理`);
                     } else {
                         node.debug(`Symi按键事件无需应答: 设备${deviceAddr} 通道${channel} 模式=${isSceneMode ? '场景' : '开关'}`);
                     }
@@ -1241,6 +1263,11 @@ module.exports = function(RED) {
                 return;
             }
 
+            // 如果未连接，静默退出，等待重连后自动触发，避免断连期间日志刷屏
+            if (!node.isConnected || !node.client || node.isClosing) {
+                return;
+            }
+
             node.isProcessingWrite = true;
 
             try {
@@ -1248,20 +1275,27 @@ module.exports = function(RED) {
                 const queueStartTime = Date.now();
                 const queueLength = node.writeQueue.length;
 
+                // 只有在队列较长时才输出调试日志
+                if (queueLength > 2) {
+                    node.log(`开始处理写入队列 (积压: ${queueLength}个任务)`);
+                }
+
                 while (node.writeQueue.length > 0) {
                     // 再次检查连接和客户端，防止处理中途断开
                     if (node.isClosing || !node.isConnected || !node.client) {
-                        node.log('处理写入队列时Modbus断开，等待重连...');
+                        node.log(`处理队列时连接断开，暂停处理 (剩余 ${node.writeQueue.length} 个任务)`);
                         break;
                     }
 
                     const task = node.writeQueue.shift();
 
                     try {
+                        node.log(`[Queue] 执行写入: 从站${task.slaveId} ${task.type === 'single' ? `线圈${task.coil}` : `批量${task.values ? task.values.length : ''}`} = ${task.value} (剩余${node.writeQueue.length})`);
+                        
                         if (task.type === 'single') {
                             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);
+                            await node._writeMultipleCoilsInternal(task.slaveId, task.startCoil, task.values, task.triggerSource);
                         } else if (task.type === 'raw') {
                             await node._writeRawInternal(task.data);
                         }
@@ -1293,8 +1327,8 @@ module.exports = function(RED) {
             } finally {
                 node.isProcessingWrite = false;
                 
-                // 检查是否在处理期间又有新任务加入
-                if (node.writeQueue.length > 0) {
+                // 检查是否在处理期间又有新任务加入，且连接正常
+                if (node.writeQueue.length > 0 && node.isConnected && !node.isClosing) {
                     setImmediate(() => node.processWriteQueue());
                 }
             }
@@ -1312,13 +1346,10 @@ module.exports = function(RED) {
 
             try {
                 // 等待锁释放
-                // 等待锁释放（写入锁优先级更高，如果是轮询锁，缩短等待时间并尝试快速夺取）
-                const maxWait = 500;
+                // 恢复为3000ms，合理的锁等待时间
+                const maxWait = 3000;
                 const startWait = Date.now();
                 while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                    if (node.modbusLockType === 'polling' && (Date.now() - startWait) > 100) {
-                        break;
-                    }
                     await new Promise(resolve => setTimeout(resolve, 20));
                 }
 
@@ -1400,18 +1431,11 @@ module.exports = function(RED) {
             const pauseStartTime = Date.now();
 
             try {
-                // 等待锁释放（写入锁优先级更高，如果是轮询锁，缩短等待时间并尝试快速夺取）
-                const maxWait = 500;
+                // 等待锁释放（写入锁优先级更高）
+                // 恢复为3000ms，合理的锁等待时间
+                const maxWait = 3000;
                 const startWait = Date.now();
                 while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                    // 如果当前是轮询锁，且我们已经等待了超过 40ms（一个基本的 Modbus 交互周期）
-                    // 我们可以标记锁可以被“抢占”，但底层驱动由于是单线程，其实还是要等 await 返回
-                    // 这里的关键是：如果是轮询锁，我们不应该等待太久
-                    if (node.modbusLockType === 'polling' && (Date.now() - startWait) > 100) {
-                        // 强制跳出等待循环，让写操作尝试继续
-                        // 注意：这只是为了防止 pollNextSlave 挂起导致锁不释放
-                        break;
-                    }
                     await new Promise(resolve => setTimeout(resolve, 20));
                 }
 
@@ -1434,9 +1458,12 @@ module.exports = function(RED) {
                 }
 
                 node.client.setID(slaveId);
+                
+                // 增加微小延迟，确保ID切换生效（某些网关/设备需要缓冲时间）
+                await new Promise(resolve => setTimeout(resolve, 5));
 
                 // 记录写入操作（帮助追踪总线数据来源）
-                node.log(`写入线圈: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
+                node.log(`[Modbus写入] 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
 
                 await node.client.writeCoil(coil, value);
 
@@ -1447,7 +1474,7 @@ module.exports = function(RED) {
                 const oldValue = node.deviceStates[slaveId].coils[coil];
                 node.deviceStates[slaveId].coils[coil] = value;
 
-                node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                node.log(`[Modbus成功] 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
 
                 // 发布到MQTT和触发事件
                 node.publishMqttState(slaveId, coil, value);
@@ -1492,6 +1519,34 @@ module.exports = function(RED) {
         // 写单个线圈（公共接口，通过队列执行）
         node.writeSingleCoil = function(slaveId, coil, value, triggerSource = 'unknown') {
             return new Promise((resolve, reject) => {
+                // 1. 全局命令去重（防止上游节点重复触发）
+                // 仅对非未知来源的触发进行去重，且仅针对同一指令（从站+线圈+值）
+                const cmdKey = `${slaveId}-${coil}-${value}`;
+                const now = Date.now();
+                const lastTime = node.commandCache.get(cmdKey) || 0;
+                
+                // 500ms 内完全相同的指令视为重复（连点保护）
+                // 注意：如果 value 不同（例如快速 ON-OFF-ON），则不会被去重，这是正确的
+                if (now - lastTime < node.commandCacheTimeout) {
+                    node.debug(`[Queue] 忽略重复写入: 从站${slaveId} 线圈${coil}=${value} (间隔${now - lastTime}ms)`);
+                    resolve();
+                    return;
+                }
+                node.commandCache.set(cmdKey, now);
+
+                // 2. 队列去重：移除旧任务
+                // 如果队列中已经有针对同一从站同一线圈的写入任务，则移除旧任务，只保留最新的
+                // 这能有效防止“连点”导致的队列积压和状态反复跳变
+                node.writeQueue = node.writeQueue.filter(task => {
+                    if (task.type === 'single' && task.slaveId === slaveId && task.coil === coil) {
+                        // 如果任务还未开始执行（在队列中），直接移除，并调用其resolve防止Promise挂起
+                        if (task.resolve) task.resolve(); 
+                        node.log(`[Queue] 合并旧任务: 从站${task.slaveId} 线圈${task.coil}`);
+                        return false;
+                    }
+                    return true;
+                });
+
                 // 添加到队列
                 node.writeQueue.push({
                     type: 'single',
@@ -1502,6 +1557,8 @@ module.exports = function(RED) {
                     resolve: resolve,
                     reject: reject
                 });
+                
+                node.debug(`[Queue] 任务入队: 从站${slaveId} 线圈${coil}=${value} (当前队列: ${node.writeQueue.length})`);
 
                 // 触发队列处理
                 node.processWriteQueue();
@@ -1509,7 +1566,7 @@ module.exports = function(RED) {
         };
         
         // 批量写入多个线圈（内部实现，不经过队列）
-        node._writeMultipleCoilsInternal = async function(slaveId, startCoil, values) {
+        node._writeMultipleCoilsInternal = async function(slaveId, startCoil, values, triggerSource = 'unknown') {
             if (node.isClosing || !node.isConnected || !node.client) {
                 throw new Error('Modbus未连接或节点正在关闭');
             }
@@ -1519,13 +1576,11 @@ module.exports = function(RED) {
             const pauseStartTime = Date.now();
 
             try {
-                // 等待锁释放（写入锁优先级更高，如果是轮询锁，缩短等待时间并尝试快速夺取）
-                const maxWait = 500;
+                // 等待锁释放
+                // 恢复为3000ms，合理的锁等待时间
+                const maxWait = 3000;
                 const startWait = Date.now();
                 while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                    if (node.modbusLockType === 'polling' && (Date.now() - startWait) > 100) {
-                        break;
-                    }
                     await new Promise(resolve => setTimeout(resolve, 20));
                 }
 
@@ -1545,7 +1600,15 @@ module.exports = function(RED) {
                 if (!node.client) {
                     throw new Error('Modbus客户端实例丢失');
                 }
+                
                 node.client.setID(slaveId);
+                
+                // 增加微小延迟，确保ID切换生效（某些网关/设备需要缓冲时间）
+                await new Promise(resolve => setTimeout(resolve, 5));
+                
+                // 记录写入操作
+                node.log(`[Modbus批量写入] 从站${slaveId} 起始线圈${startCoil} 共${values.length}个 (触发源: ${triggerSource})`);
+                
                 await node.client.writeCoils(startCoil, values);
 
                 // 记录写入时间（用于暂停轮询）
@@ -1574,7 +1637,8 @@ module.exports = function(RED) {
                             slave: slaveId,
                             coil: coilIndex,
                             value: newValue,
-                            source: 'write'
+                            source: 'write',
+                            triggerSource: triggerSource  // 传递触发源标识
                         });
                     }
                 }
@@ -1601,7 +1665,7 @@ module.exports = function(RED) {
         };
 
         // 批量写入多个线圈（公共接口，通过队列执行）
-        node.writeMultipleCoils = function(slaveId, startCoil, values) {
+        node.writeMultipleCoils = function(slaveId, startCoil, values, triggerSource = 'unknown') {
             return new Promise((resolve, reject) => {
                 // 添加到队列
                 node.writeQueue.push({
@@ -1609,6 +1673,7 @@ module.exports = function(RED) {
                     slaveId: slaveId,
                     startCoil: startCoil,
                     values: values,
+                    triggerSource: triggerSource,
                     resolve: resolve,
                     reject: reject
                 });
@@ -1632,29 +1697,56 @@ module.exports = function(RED) {
 
             // 检查主站关联（如果指定了主站ID，则必须匹配）
             if (data.masterId && data.masterId !== node.id) {
-                // 如果是针对本主站的从站，但ID不匹配，记录日志辅助排查
-                const hasSlave = node.config.slaves.find(s => s.address === slave);
-                if (hasSlave) {
-                    node.log(`忽略写入事件：从站${slave}在配置中，但masterId不匹配 (收到:${data.masterId}, 本机:${node.id})`);
-                }
+                // 如果 masterId 不匹配，绝对不能处理，否则会导致多主站冲突
                 return;
             }
 
+            // 如果是广播事件（没有 masterId），但当前主站不是 relay-output 预期指向的主站，也应谨慎处理
+            // 注意：内部事件通信强制要求 masterId，广播仅用于旧版兼容
+            if (!data.masterId) {
+                // 如果是广播，只有在配置中包含该从站时才尝试处理
+                const hasSlave = node.config.slaves.find(s => parseInt(s.address) === slave);
+                if (!hasSlave) return;
+                
+                // 增加一条调试信息，提示广播可能带来的潜在冲突
+                node.debug(`[免连线联动] 收到广播写入事件(从站${slave})，主站(${node.config.name || node.id})尝试执行。建议检查 relay-output 节点配置。`);
+            }
+
             // 检查该主站是否配置了此从站
-            const slaveConfig = node.config.slaves.find(s => s.address === slave);
+            const slaveConfig = node.config.slaves.find(s => parseInt(s.address) === slave);
             if (!slaveConfig) {
-                // node.log(`忽略写入事件：主站未配置从站${slave}`);
+                // 如果是针对本主站的明确写入（带 masterId），但未配置该从站，则给出警告
+                if (data.masterId) {
+                    node.warn(`[免连线联动] 忽略明确写入：主站(${node.id})未配置从站${slave}。`);
+                }
                 return;
             }
 
             // 输出日志确认收到事件
-            node.log(`收到内部写入事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
+            const masterName = node.config.name || "未命名主站";
+            const targetMasterInfo = data.masterId === node.id ? `匹配成功 (${masterName})` : (data.masterId || '广播模式');
+            
+            // 精简日志：明确主站写入时输出一条信息
+            if (data.masterId) {
+                // 增加校验：如果 masterId 存在但为空字符串，视为广播
+                if (typeof data.masterId === 'string' && data.masterId.trim() === '') {
+                     node.debug(`[免连线联动] 收到无效masterId(空字符串)，视为广播模式`);
+                } else {
+                     // 增加 masterId 匹配校验（防御性编程，虽然上面已经 check 过了）
+                     if (data.masterId === node.id) {
+                         node.log(`[免连线联动] 触发写入: 从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
+                     } else {
+                         // 理论上走不到这里，因为上面有 data.masterId !== node.id 的 check
+                         node.debug(`[免连线联动] 忽略不匹配的masterId: ${data.masterId} (本站: ${node.id})`);
+                     }
+                }
+            } else {
+                node.debug(`[免连线联动] 目标主站: ${targetMasterInfo} | 触发源: ${triggerSource}`);
+            }
 
             try {
                 // 执行写入操作（writeSingleCoil内部已经会广播状态变化事件）
                 await node.writeSingleCoil(slave, coil, value, triggerSource);
-
-                node.log(`内部事件写入成功：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
             } catch (err) {
                 node.log(`内部事件写入失败: 从站${slave} 线圈${coil} - ${err.message}`);
             }
@@ -1711,10 +1803,11 @@ module.exports = function(RED) {
                         const slave = parseInt(msg.payload.slave);
                         const startCoil = parseInt(msg.payload.startCoil);
                         const values = msg.payload.values.map(v => Boolean(v));
+                        const triggerSource = msg.payload.triggerSource || 'write-multiple-coils';
 
-                        node.log(`接收到本地模式批量写入命令: 从站${slave} 起始线圈${startCoil} 共${values.length}个`);
+                        node.log(`接收到本地模式批量写入命令: 从站${slave} 起始线圈${startCoil} 共${values.length}个 (触发源: ${triggerSource})`);
 
-                        node.writeMultipleCoils(slave, startCoil, values).catch(err => {
+                        node.writeMultipleCoils(slave, startCoil, values, triggerSource).catch(err => {
                             node.log(`本地模式批量写入失败: ${err.message}`);
                         });
                     } else {

package/nodes/modbus-slave-switch.js

@@ -25,6 +25,10 @@ module.exports = function(RED) {
     // key: "serialPortConfigId:meshShortAddress", value: {timer, nodeId, serialPortConfig}
     const meshLedDebounceTimers = new Map();
 
+    // 全局按钮关联继电器状态表（用于多对一控制时的LED状态聚合）
+    // key: "serialPortConfigId:switchId:buttonNumber", value: Map<nodeId, boolean>
+    const globalButtonRelayStates = new Map();
+
     // 辅助函数：获取带作用域的键名
     // 确保configId始终有效，避免返回"unknown"前缀导致防抖键不匹配
     function getScopedKey(node, key) {
@@ -392,6 +396,8 @@ module.exports = function(RED) {
             targetCoilNumber: modbusCoilNumber,  // 目标继电器线圈编号（0-31，从用户输入的1-32转换）
             modbusMaster: config.modbusMaster || ""  // 关联的主站节点ID
         };
+        
+        node.debug(`初始化开关节点: ID=${node.config.switchId} Btn=${node.config.buttonNumber} -> 目标从站=${node.config.targetSlaveAddress} 线圈=${node.config.targetCoilNumber} (用户输入:${userCoilNumber})`);
 
         node.currentState = false;
         node.isRs485Connected = false;
@@ -536,9 +542,11 @@ module.exports = function(RED) {
                 // 检查是否是当前面板触发的操作
                 const isTriggerSourcePanel = (node.serialPortConfig && node.serialPortConfig.triggerSource === panelKey);
 
-                // 检查主站关联（如果配置了主站，则只响应对应主站的消息）
+                // 检查主站关联
                 if (node.config.modbusMaster && masterId && node.config.modbusMaster !== masterId) {
-                    return;
+                    // 严格隔离：只要 MasterID 不匹配，直接忽略
+                    // 即使 Slave/Coil 相同，也是不同总线上的不同设备
+                    return; 
                 }
 
                 // 检查是否是我们关注的从站和线圈
@@ -555,6 +563,17 @@ module.exports = function(RED) {
                     node.lastStateChange.timestamp = Date.now();
                     node.lastStateChange.value = value;
 
+                    // 更新全局继电器状态表（用于LED反馈聚合）
+                    // 即使是单控模式，也通过此表统一管理状态
+                    const relayStateKey = getScopedKey(node, `relay-state-${isMesh ? panelKey : node.config.switchId}-${node.config.buttonNumber}`);
+                    if (!globalButtonRelayStates.has(relayStateKey)) {
+                        globalButtonRelayStates.set(relayStateKey, new Map());
+                    }
+                    globalButtonRelayStates.get(relayStateKey).set(node.id, value);
+
+                    // 计算聚合状态（OR逻辑：只要有一个关联继电器为ON，指示灯就为ON）
+                    const aggregatedState = Array.from(globalButtonRelayStates.get(relayStateKey).values()).some(v => v === true);
+
                     // Mesh 模式：更新全局共享状态缓存
                     if (isMesh && panelKey) {
                         const statesKey = getScopedKey(node, panelKey);
@@ -565,8 +584,9 @@ module.exports = function(RED) {
                         if (node.config.meshButtonNumber > 0 && node.config.meshButtonNumber <= states.length) {
                             // 优化：只有当值真正有效（非 null）或初始化时，才更新缓存
                             // 避免在全控过程中，由于某些按键未同步到状态而导致的 null 覆盖有效值
-                            if (value !== null || states[node.config.meshButtonNumber - 1] === null) {
-                                states[node.config.meshButtonNumber - 1] = value;
+                            // 使用聚合后的状态更新缓存
+                            if (aggregatedState !== null || states[node.config.meshButtonNumber - 1] === null) {
+                                states[node.config.meshButtonNumber - 1] = aggregatedState;
                             }
                         }
                     }
@@ -574,67 +594,159 @@ module.exports = function(RED) {
                         if (stateChanged) {
                             // 核心逻辑：状态发生变化时，启动 LED 同步防抖队列
                             // 防抖机制（200ms）确保在全开/全关等批量场景下，能够收集完整状态并平滑同步
-                            if (isInit) {
-                                node.debug(`[LED反馈] 跳过初始化阶段的同步请求`);
+                            const panelId = isMesh ? panelKey : node.config.switchId;
+                            const debounceKey = getScopedKey(node, panelId);
+                            let timerObj = meshLedDebounceTimers.get(debounceKey);
+
+                            if (!timerObj) {
+                                timerObj = {
+                                    timer: null,
+                                    nodeId: node.id,
+                                    serialPortConfig: node.serialPortConfig,
+                                    firstChangeTime: Date.now(),
+                                    changeCount: 0,
+                                    targetNodes: new Set([node])
+                                };
+                                meshLedDebounceTimers.set(debounceKey, timerObj);
                             } else {
-                                const panelId = isMesh ? panelKey : node.config.switchId;
-                                const debounceKey = getScopedKey(node, panelId);
-                                let timerObj = meshLedDebounceTimers.get(debounceKey);
-
-                                if (!timerObj) {
-                                    timerObj = {
-                                        timer: null,
-                                        nodeId: node.id,
-                                        serialPortConfig: node.serialPortConfig,
-                                        firstChangeTime: Date.now(),
-                                        changeCount: 0,
-                                        targetNodes: new Set([node])
-                                    };
-                                    meshLedDebounceTimers.set(debounceKey, timerObj);
-                                } else {
-                                    timerObj.targetNodes.add(node);
-                                }
+                                timerObj.targetNodes.add(node);
+                            }
 
-                                timerObj.changeCount++;
-                                if (timerObj.timer) clearTimeout(timerObj.timer);
+                            timerObj.changeCount++;
+                            if (timerObj.timer) clearTimeout(timerObj.timer);
 
-                                // 统一使用 200ms 防抖，确保在大批量操作时收集完整状态
-                                const debounceTime = 200;
+                            // 统一使用 200ms 防抖，确保在大批量操作时收集完整状态
+                            const debounceTime = isInit ? 50 : 200;
 
-                                timerObj.timer = setTimeout(() => {
-                                    const currentTimerObj = meshLedDebounceTimers.get(debounceKey);
-                                    if (currentTimerObj) {
-                                        meshLedDebounceTimers.delete(debounceKey);
-                                        
-                                        if (currentTimerObj.serialPortConfig && currentTimerObj.serialPortConfig.setFeedbackLock) {
-                                            // 缩短锁定时间从 150ms 到 50ms，确保能及时捕获从站的真实状态报告
-                                            currentTimerObj.serialPortConfig.setFeedbackLock(50);
+                            timerObj.timer = setTimeout(() => {
+                                const currentTimerObj = meshLedDebounceTimers.get(debounceKey);
+                                if (currentTimerObj) {
+                                    meshLedDebounceTimers.delete(debounceKey);
+                                    
+                                    if (currentTimerObj.serialPortConfig && currentTimerObj.serialPortConfig.setFeedbackLock) {
+                                        // 锁定反馈，防止回显
+                                        currentTimerObj.serialPortConfig.setFeedbackLock(100);
+                                    }
+                                    
+                                    if (isMesh) {
+                                        const representativeNode = currentTimerObj.targetNodes.values().next().value;
+                                        if (representativeNode) {
+                                            const changedButtons = new Set();
+                                            currentTimerObj.targetNodes.forEach(n => {
+                                                if (n.config.meshButtonNumber) changedButtons.add(parseInt(n.config.meshButtonNumber));
+                                            });
+                                            // Mesh模式下，sendCommandToPanel 会从 meshDeviceStates 读取状态
+                                            // 我们已经在上面更新了 meshDeviceStates 为 aggregatedState
+                                            // 注意：传入第一个参数其实在 sendCommandToPanel 内部对于 Mesh 模式是不直接使用的（它用 currentStates）
+                                            // 但为了保持一致性，我们还是传 aggregatedState (虽然这里拿不到具体的 aggregatedState，传 local state 也没关系)
+                                            representativeNode.sendCommandToPanel(representativeNode.currentState, false, changedButtons);
                                         }
-                                        
-                                        if (isMesh) {
-                                            const representativeNode = currentTimerObj.targetNodes.values().next().value;
-                                            if (representativeNode) {
-                                                const changedButtons = new Set();
-                                                currentTimerObj.targetNodes.forEach(n => {
-                                                    if (n.config.meshButtonNumber) changedButtons.add(parseInt(n.config.meshButtonNumber));
+                                    } else {
+                                        // 485/Clowire 模式：按按钮分组发送，确保多控一/一对多场景下状态正确
+                                        // 排序：先按 switchId，再按 buttonNumber，确保处理顺序一致
+                                        const sortedNodes = Array.from(currentTimerObj.targetNodes).sort((a, b) => {
+                                            if (a.config.switchId !== b.config.switchId) return a.config.switchId - b.config.switchId;
+                                            return a.config.buttonNumber - b.config.buttonNumber;
+                                        });
+
+                                        // 找出所有涉及的面板 ID (switchId)
+                                        const panelIds = new Set();
+                                        sortedNodes.forEach(node => panelIds.add(node.config.switchId));
+
+                                        // 针对每个面板，单独处理
+                                        panelIds.forEach(panelId => {
+                                            // 找到该面板的一个代表节点（用于获取配置和发送指令）
+                                            const representativeNode = sortedNodes.find(n => n.config.switchId === panelId);
+                                            if (!representativeNode) return;
+
+                                            // 检查该面板的所有按键状态
+                                            // 1. 获取该面板下所有已配置的节点（不仅仅是本次变更的节点）
+                                            // 由于 globalButtonRelayStates 是全局的，我们可以遍历它来检查状态
+                                            
+                                            const configId = (representativeNode.serialPortConfig && representativeNode.serialPortConfig.id) || representativeNode.id || "default";
+                                            let anyOn = false;
+                                            
+                                            // 遍历检查该面板的所有可能按键（1-8）
+                                            // 只要发现有一个按键是 ON，就不能使用全关指令
+                                            for (let i = 1; i <= 8; i++) {
+                                                const key = `${configId}:relay-state-${panelId}-${i}`;
+                                                if (globalButtonRelayStates.has(key)) {
+                                                    const stateMap = globalButtonRelayStates.get(key);
+                                                    const isBtnOn = Array.from(stateMap.values()).some(v => v === true);
+                                                    if (isBtnOn) {
+                                                        anyOn = true;
+                                                        // representativeNode.debug(`[LED优化] 面板${panelId} 按键${i} 仍为 ON，跳过全关`);
+                                                        break;
+                                                    }
+                                                }
+                                            }
+
+                                            // Clowire/Symi 协议优化：如果该面板所有已知的按键状态都为 OFF，则发送一条“全关”指令
+                                            let useGlobalOff = false;
+                                            if (!anyOn) {
+                                                if (representativeNode.config.switchBrand === 'clowire') {
+                                                    useGlobalOff = true;
+                                                } else if (representativeNode.config.switchBrand === 'symi') {
+                                                    useGlobalOff = false;
+                                                }
+                                            }
+
+                                            if (useGlobalOff && representativeNode.serialPortConfig) {
+                                                try {
+                                                    let cmd = null;
+                                                    if (representativeNode.config.switchBrand === 'clowire') {
+                                                        // Clowire 全关指令 (0x1020 -> 0x0002)
+                                                        cmd = clowireProtocol.buildTurnOffAllLedsCommand(panelId);
+                                                        representativeNode.debug(`[LED优化] Clowire面板${panelId} 全关`);
+                                                    } else if (representativeNode.config.switchBrand === 'symi') {
+                                                        // Symi 全关指令 (OpCode=0x05, States=0x00)
+                                                        // 使用 SET (0x03)
+                                                        cmd = protocol.buildMultiLightCommand(0x00, panelId, 0, 0, 0);
+                                                        representativeNode.debug(`[LED优化] Symi面板${panelId} 全关 (SET模式)`);
+                                                    }
+
+                                                    if (cmd) {
+                                                        // 统一使用高优先级
+                                                        representativeNode.serialPortConfig.write(cmd, (err) => {
+                                                            if (err) {
+                                                                representativeNode.error(`发送全关指令失败: ${err.message}`);
+                                                            }
+                                                        }, 1, panelId);
+                                                    }
+                                                } catch (err) {
+                                                    representativeNode.error(`构建全关指令异常: ${err.message}`);
+                                                }
+                                            } else {
+                                                // 标准逻辑：逐个发送
+                                                // 只发送本次变更涉及的节点
+                                                const processedButtons = new Set();
+                                                sortedNodes.forEach(targetNode => {
+                                                    // 过滤掉非当前面板的节点
+                                                    if (targetNode.config.switchId !== panelId) return;
+
+                                                    const btnNum = targetNode.config.buttonNumber;
+                                                    if (processedButtons.has(btnNum)) return;
+                                                    processedButtons.add(btnNum);
+
+                                                    // 获取该按钮的聚合状态
+                                                    const rKey = getScopedKey(targetNode, `relay-state-${panelId}-${btnNum}`);
+                                                    const stateMap = globalButtonRelayStates.get(rKey);
+                                                    // 如果找不到映射（理论上不可能），降级使用节点自身状态
+                                                    const aggState = stateMap ? Array.from(stateMap.values()).some(v => v === true) : targetNode.currentState;
+
+                                                    targetNode.sendCommandToPanel(aggState, false);
                                                 });
-                                                // 强制 isTriggerSource=false，确保这里发出的都是同步指令
-                                                representativeNode.sendCommandToPanel(representativeNode.currentState, false, changedButtons);
                                             }
-                                        } else {
-                                            currentTimerObj.targetNodes.forEach(targetNode => {
-                                                targetNode.sendCommandToPanel(targetNode.currentState, false);
-                                            });
-                                        }
+                                        });
                                     }
-                                }, debounceTime);
-                            }
+                                }
+                            }, debounceTime);
                         }
 
                         node.updateStatus();
 
                         if (isInit) {
-                            node.debug(`首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}（不发送到下游）`);
+                            node.debug(`初始化状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
                             return;
                         }
 
@@ -843,18 +955,28 @@ module.exports = function(RED) {
 
                     // 全局防抖（基于面板ID和按键编号，不包含从站地址）
                     // 这样同一个按键事件只会被处理一次LED反馈，但每个节点都会发送MQTT命令
+                    // 修改：针对命令发送（MQTT/内部事件）的防抖，key 必须包含 targetSlaveAddress，
+                    // 否则如果配置了多个从站开关节点（对应同一个物理按键但控制不同继电器），
+                    // 会被误判为重复命令而只触发第一个。
                     const ledDebounceKey = getScopedKey(node, `led-${node.config.switchId}-${node.config.buttonNumber}`);
-                    const commandDebounceKey = getScopedKey(node, `cmd-${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}`);
+                    // 增加 targetCoilNumber 到 key 中，确保同一从站不同线圈也能独立触发（虽然少见）
+                    const commandDebounceKey = getScopedKey(node, `cmd-${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
                     const now = Date.now();
                     
                     // 检查命令防抖（每个节点独立）
+                    // 只有针对完全相同的目标（同一从站、同一线圈）才进行防抖
                     const lastCommandTime = globalDebounceCache.get(commandDebounceKey) || 0;
                     if (now - lastCommandTime < 200) {
+                        // node.debug(`忽略重复命令: 面板${node.config.switchId} 按键${node.config.buttonNumber} -> 从站${node.config.targetSlaveAddress} (间隔${now - lastCommandTime}ms)`);
                         return;
                     }
                     globalDebounceCache.set(commandDebounceKey, now);
 
                     // 检查LED反馈防抖（同一面板同一按键共享）
+                    // 调试日志：确认按键触发及目标
+                    // node.debug(`[按键触发] 面板${node.config.switchId} 按键${node.config.buttonNumber} -> 目标从站${node.config.targetSlaveAddress} 线圈${node.config.targetCoilNumber}`);
+
+                    // 多个节点共享同一个物理按键的 LED 反馈，只需要发送一次
                     const lastLedTime = globalDebounceCache.get(ledDebounceKey) || 0;
                     const shouldSendLed = (now - lastLedTime >= 200);
                     if (shouldSendLed) {
@@ -889,7 +1011,10 @@ module.exports = function(RED) {
                         if (shouldSendLed) {
                             if (node.serialPortConfig && node.serialPortConfig.setFeedbackLock) {
                                 // 统一使用 50ms 锁定，防止反馈回显触发误判
-                                node.serialPortConfig.setFeedbackLock(50);
+                                // 使用 setTimeout 延迟锁定，确保当前帧能被所有并行的节点处理完毕
+                                setTimeout(() => {
+                                    node.serialPortConfig.setFeedbackLock(50);
+                                }, 1);
                             }
                             node.sendCommandToPanel(node.currentState);
                         }
@@ -917,7 +1042,10 @@ module.exports = function(RED) {
                         if (shouldSendLed) {
                             if (node.serialPortConfig && node.serialPortConfig.setFeedbackLock) {
                                 // 延长反馈锁时间至 100ms，确保总线回显被彻底过滤
-                                node.serialPortConfig.setFeedbackLock(100);
+                                // 使用 setTimeout 延迟锁定，确保当前帧能被所有并行的节点处理完毕
+                                setTimeout(() => {
+                                    node.serialPortConfig.setFeedbackLock(100);
+                                }, 1);
                             }
                             // 传入 true 表示这是由物理按键触发的强制反馈
                             node.sendCommandToPanel(buttonEvent.state, true);
@@ -961,7 +1089,7 @@ module.exports = function(RED) {
                     // 处理感应器事件（通道0x0F，buttonNumber=15）
                     if (event.type === 'sensor' && node.config.buttonNumber === 15) {
                         // 感应器模式：有人/无人状态，复用按键背光灯配置
-                        const debounceKey = getScopedKey(node, `clowire-sensor-${node.config.switchId}-${node.config.targetSlaveAddress}`);
+                        const debounceKey = getScopedKey(node, `clowire-sensor-${node.config.switchId}-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
                         const now = Date.now();
                         const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
@@ -994,13 +1122,13 @@ module.exports = function(RED) {
                     if (event.type === 'button' && event.buttonNumber === node.config.buttonNumber) {
                         // 全局防抖（基于面板ID和按键编号，不包含从站地址）
                         const ledDebounceKey = getScopedKey(node, `clowire-led-${node.config.switchId}-${node.config.buttonNumber}`);
-                        const commandDebounceKey = getScopedKey(node, `clowire-cmd-${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}`);
+                        const commandDebounceKey = getScopedKey(node, `clowire-cmd-${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
                         const now = Date.now();
                         
                         // 检查命令防抖（每个节点独立）
                         const lastCommandTime = globalDebounceCache.get(commandDebounceKey) || 0;
                         if (now - lastCommandTime < 200) {
-                            continue;
+                            return;
                         }
                         globalDebounceCache.set(commandDebounceKey, now);
 
@@ -1036,7 +1164,10 @@ module.exports = function(RED) {
                         
                         // 只有第一个处理的节点发送LED反馈
                         if (shouldSendLed) {
-                            node.sendCommandToPanel(node.currentState);
+                            // 延迟 1200ms 发送 LED 反馈，避开 Modbus Master 控制继电器的总线高峰期
+                            setTimeout(() => {
+                                node.sendCommandToPanel(node.currentState);
+                            }, 1200);
                         }
 
                         // 输出消息
@@ -1112,11 +1243,11 @@ module.exports = function(RED) {
                 if (isSceneMode) {
                     // 场景模式：全局防抖（200ms内只触发一次）
                     // 包含targetSlaveAddress，允许一个按键控制多个不同从站的继电器
-                    const debounceKey = getScopedKey(node, `mesh-scene-${node.config.meshShortAddress}-${node.config.meshButtonNumber}-${node.config.targetSlaveAddress}`);
+                    const debounceKey = getScopedKey(node, `mesh-scene-${node.config.meshShortAddress}-${node.config.meshButtonNumber}-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
                     const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
                     if (now - lastTriggerTime < 200) {
-                        node.debug(`[Mesh场景] 全局防抖忽略：设备${meshAddr} 按键${node.config.meshButtonNumber} (${now - lastTriggerTime}ms内)`);
+                        // node.debug(`[Mesh场景] 全局防抖忽略：设备${meshAddr} 按键${node.config.meshButtonNumber} (${now - lastTriggerTime}ms内)`);
                         return;
                     }
                     globalDebounceCache.set(debounceKey, now);
@@ -1164,13 +1295,13 @@ module.exports = function(RED) {
 
                     // 第四步：全局防抖：防止同一个按键的同一个目标重复触发
                     // 包含targetSlaveAddress，允许一个按键控制多个不同从站的继电器
-                    const debounceKey = getScopedKey(node, `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}-${node.config.targetSlaveAddress}`);
+                    const debounceKey = getScopedKey(node, `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
                     now = Date.now();
                     const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
                     // 全局防抖：200ms内只触发一次
                     if (now - lastTriggerTime < 200) {
-                        node.debug(`[Mesh事件] 全局防抖忽略：设备${meshAddr} 按键${node.config.meshButtonNumber} (${now - lastTriggerTime}ms内)`);
+                        // node.debug(`[Mesh事件] 全局防抖忽略：设备${meshAddr} 按键${node.config.meshButtonNumber} (${now - lastTriggerTime}ms内)`);
                         return; // 静默忽略重复触发
                     }
                     globalDebounceCache.set(debounceKey, now);
@@ -1250,14 +1381,30 @@ module.exports = function(RED) {
             // 模式2：内部事件模式（通过RED内部事件系统，免连线通信）
             // 当MQTT未启用或未连接时，通过内部事件发送控制命令
             // 主站节点会监听这些事件并执行写入操作
+
+            // 确定目标主站 ID
+            // 如果配置了主站但节点不存在，则降级为广播模式（不带 masterId），让所有主站尝试处理
+            let targetMasterId = node.config.modbusMaster || "";
+            if (targetMasterId && !RED.nodes.getNode(targetMasterId)) {
+                node.debug(`指定的配置主站 ${targetMasterId} 不存在，切换到广播模式`);
+                targetMasterId = undefined;
+            }
+
+            // 明确触发源
+            const triggerSource = isSceneMode ? 'scene-trigger' : 'button-press';
+            const slaveAddr = parseInt(node.config.targetSlaveAddress);
+            const coilNum = parseInt(node.config.targetCoilNumber);
+
+            node.debug(`[sendMqttCommand] 准备发送内部事件: 从站${slaveAddr} 线圈${coilNum} = ${state} (源: ${triggerSource}, 目标主站: ${targetMasterId || '广播'})`);
+
             RED.events.emit('modbus:writeCoil', {
-                slave: node.config.targetSlaveAddress,
-                coil: node.config.targetCoilNumber,
+                slave: slaveAddr,
+                coil: coilNum,
                 value: state,
                 source: 'slave-switch',
-                triggerSource: isSceneMode ? 'scene-trigger' : 'button-press',  // 场景模式使用scene-trigger，开关模式使用button-press
+                triggerSource: triggerSource,  // 场景模式使用scene-trigger，开关模式使用button-press
                 nodeId: node.id,
-                masterId: node.config.modbusMaster || "", // 指定目标主站ID
+                masterId: targetMasterId, // 指定目标主站ID
                 serialPortConfigId: config.serialPortConfig // 增加串口配置ID，用于主站过滤，防止多主站冲突
             });
 
@@ -1823,6 +1970,15 @@ module.exports = function(RED) {
             const panelKey = isMesh ? node.config.meshShortAddress : node.config.switchId;
             const debounceKey = getScopedKey(node, isMesh ? panelKey : `${panelKey}-${node.id}`);
 
+            // 从全局继电器状态表中移除当前节点
+            const relayStateKey = getScopedKey(node, `relay-state-${isMesh ? panelKey : node.config.switchId}-${node.config.buttonNumber}`);
+            if (globalButtonRelayStates.has(relayStateKey)) {
+                globalButtonRelayStates.get(relayStateKey).delete(node.id);
+                if (globalButtonRelayStates.get(relayStateKey).size === 0) {
+                    globalButtonRelayStates.delete(relayStateKey);
+                }
+            }
+
             if (panelKey && meshLedDebounceTimers.has(debounceKey)) {
                 const timerObj = meshLedDebounceTimers.get(debounceKey);
                 if (timerObj && timerObj.timer) {

package/nodes/relay-output.html

@@ -44,7 +44,7 @@
             // 填充主站节点选择器
             var masterNodeSelect = $("#node-input-masterNode");
             masterNodeSelect.empty();
-            masterNodeSelect.append('<option value="">请选择主站节点</option>');
+            masterNodeSelect.append('<option value="">自动查找 (跨主站联动)</option>');
 
             // 查找所有modbus-master节点
             var masters = [];
@@ -110,10 +110,10 @@
                 var buttonType = $("#node-input-buttonType").val();
                 var masterNodeId = $("#node-input-masterNode").val();
                 
-                var masterLabel = "未选择主站";
+                var masterLabel = "自动查找";
                 if (masterNodeId) {
                     var masterNode = RED.nodes.node(masterNodeId);
-                    masterLabel = masterNode ? (masterNode.name || `主站 ${masterNodeId.substring(0, 8)}`) : "未知主站";
+                    masterLabel = masterNode ? (masterNode.name || `主站 ${masterNodeId.substring(0, 8)}`) : "未知主站 (将尝试自动查找)";
                 }
                 
                 const actionMap = { 'on': '打开', 'off': '关闭', 'follow': '跟随', 'toggle': '翻转' };

package/nodes/relay-output.js

@@ -38,6 +38,8 @@ module.exports = function(RED) {
         node.isClosing = false;
         node.pendingTimer = null;  // 延时定时器
         node.stateChangeListener = null;  // 状态变化监听器
+        node.coilStateListener = null;    // 目标线圈状态监听器
+        node.currentCoilState = null;     // 缓存当前线圈状态，用于实现真正的翻转(Toggle)逻辑
 
         // 初始化后延迟启动（防止重启时自动动作）
         node.initialized = false;
@@ -65,6 +67,7 @@ module.exports = function(RED) {
                 // 解决多网关环境下的冲突问题
                 if (!node.ignoreGatewayId && node.serialPortConfig && data.serialPortConfigId) {
                     if (node.serialPortConfig !== data.serialPortConfigId) {
+                        node.debug(`[网关过滤] 忽略来自不同网关的事件: 节点=${node.serialPortConfig}, 收到=${data.serialPortConfigId}`);
                         return;
                     }
                 }
@@ -74,11 +77,8 @@ module.exports = function(RED) {
                 const msgButtonNumber = data.button || data.buttonNumber;
 
                 // 增加调试日志，帮助用户排查跨网关联动问题
-                // 仅在 ID 匹配时输出按键不匹配的情况，避免日志刷屏
                 if (parseInt(msgSwitchId) === node.switchId) {
-                     if (parseInt(msgButtonNumber) !== node.buttonNumber) {
-                         node.debug(`[跨网关] 收到开关 ${msgSwitchId} 事件，但按键编号不匹配 (收到:${msgButtonNumber}, 监听:${node.buttonNumber})`);
-                     }
+                     node.debug(`[触发源检测] 开关ID匹配: ${msgSwitchId}, 收到按键: ${msgButtonNumber}, 监听按键: ${node.buttonNumber}`);
                 }
 
                 // 开关ID必须匹配
@@ -103,7 +103,7 @@ module.exports = function(RED) {
 
                 // 执行控制
                 const btnLabel = msgButtonNumber == 15 ? '背光灯' : `按键${msgButtonNumber}`;
-                const triggerSource = data.type === 'scene' ? 'scene-trigger' : 'button-press';
+                const triggerSource = (data.type === 'scene' || data.isSceneMode) ? 'scene-trigger' : 'button-press';
                 node.executeControl(triggerValue, `开关${msgSwitchId}-${btnLabel}`, triggerSource);
             };
 
@@ -112,24 +112,58 @@ module.exports = function(RED) {
             node.log(`绑定触发源: 开关${node.switchId} ${btnLabel}`);
         }
 
+        // 监听目标线圈状态变化（用于状态同步和实现 Toggle 逻辑）
+        node.coilStateListener = function(data) {
+            // 过滤：必须是配置的主站、从站和线圈
+            if (data.masterId === node.masterNodeId && 
+                parseInt(data.slave) === node.slaveAddress && 
+                parseInt(data.coil) === (node.coilNumber - 1)) {
+                
+                const oldState = node.currentCoilState;
+                node.currentCoilState = data.value;
+                
+                // 如果状态发生变化，更新节点状态显示（非动作触发时的被动更新）
+                if (oldState !== node.currentCoilState) {
+                    const actionText = node.currentCoilState ? 'ON' : 'OFF';
+                    node.updateStatus(`同步状态: ${actionText} ← 从站${node.slaveAddress}`, node.currentCoilState ? 'green' : 'grey');
+                }
+            }
+        };
+        RED.events.on('modbus:coilStateChanged', node.coilStateListener);
+
         // 发送写入命令到主站（通过内部事件）
         node.sendWriteCommand = function(value, source, triggerSource = 'relay-control') {
             const coilIndex = node.coilNumber - 1;  // 用户输入1-32，内部使用0-31
             
+            // 确定目标主站 ID
+            // 必须严格使用配置的主站节点，不允许自动切换到广播模式
+            // 否则在多主站环境下（多个主站都有相同从站地址时）会导致控制混乱
+            const targetMasterId = node.masterNodeId;
+            
+            if (!targetMasterId) {
+                node.warn(`[继电器输出] 节点未配置目标主站，指令将无法发送。请在节点配置中选择正确的主站。`);
+                return;
+            }
+
+            if (!RED.nodes.getNode(targetMasterId)) {
+                node.error(`[继电器输出] 配置的目标主站 ${targetMasterId} 不存在或未部署。`);
+                return;
+            }
+
             RED.events.emit('modbus:writeCoil', {
                 slave: node.slaveAddress,
                 coil: coilIndex,
                 value: value,
                 source: 'relay-output',
                 triggerSource: triggerSource,
-                masterId: node.masterNodeId,
+                masterId: targetMasterId,
                 nodeId: node.id
             });
 
             const actionText = value ? '打开' : '关闭';
             const sourceText = source ? ` (${source})` : '';
             node.updateStatus(`${actionText} → 从站${node.slaveAddress}线圈${node.coilNumber}${sourceText}`, value ? 'green' : 'grey');
-            node.log(`继电器输出: 从站${node.slaveAddress} 线圈${node.coilNumber} ${actionText}${sourceText}`);
+            node.debug(`[联动执行] 触发写入: 从站=${node.slaveAddress}, 线圈=${node.coilNumber}, 值=${value}, 目标主站=${targetMasterId || '广播'}${sourceText}`);
         };
 
         // 执行控制逻辑
@@ -147,8 +181,16 @@ module.exports = function(RED) {
                     targetValue = triggerValue;
                     break;
                 case 'toggle':
+                // 翻转逻辑：基于当前已知的继电器状态进行翻转
+                // 如果当前状态未知（null），则默认发送反向指令
+                if (node.currentCoilState === null) {
+                    node.warn(`[继电器输出] 翻转动作触发，但从站${node.slaveAddress}状态未知，发送反转指令`);
                     targetValue = !triggerValue;
-                    break;
+                } else {
+                    targetValue = !node.currentCoilState;
+                    node.debug(`[继电器输出] 翻转动作: 当前状态=${node.currentCoilState} -> 目标状态=${targetValue}`);
+                }
+                break;
                 default:
                     targetValue = true;
             }
@@ -225,7 +267,7 @@ module.exports = function(RED) {
         });
 
         // 节点关闭时清理
-        node.on('close', function(done) {
+        node.on('close', function(removed, done) {
             node.isClosing = true;
 
             // 清除初始化定时器
@@ -246,6 +288,15 @@ module.exports = function(RED) {
                 node.stateChangeListener = null;
             }
 
+            if (node.coilStateListener) {
+                RED.events.removeListener('modbus:coilStateChanged', node.coilStateListener);
+                node.coilStateListener = null;
+            }
+
+            if (removed) {
+                // 节点被删除时的额外清理（如果有）
+            }
+
             done();
         });
     }

package/package.json

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