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

package/README.md

@@ -32,6 +32,8 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
   - **门禁联动过滤**：继电器节点支持门禁ID过滤，实现精确的门禁联动控制
   - **HomeKit网桥**：一键接入Apple HomeKit，支持Siri语音控制，状态实时同步
   - **智能写入队列**：所有写入操作串行执行，支持优先级管理，确保指示灯反馈在群控场景下秒级响应
+  - **多主站精准隔离**：支持多主站并行运行，通过 `masterId` 实现指令精准定向，彻底解决多主站环境下的控制冲突
+  - **真·状态翻转逻辑**：继电器输出节点内置状态感知能力，基于物理设备真实反馈执行翻转操作，解决传统盲发指令导致的开关失灵
 - **可视化运维**：
   - **控制看板**：实时显示所有继电器状态，支持手动控制
   - **调试模式**：详细的通信日志，支持十六进制报文监控
@@ -957,6 +959,20 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本更新说明
 
+### 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 +994,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 +1018,13 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - **多连接支持**：支持 Mac/Linux 多串口与 TCP 同时运行，各主站实例完全隔离，互不干扰。
 - **断电恢复**：所有状态和配置自动持久化，设备上电后 1 秒内自动同步最新状态。
 - **日志防护**：错误日志限流与磁盘溢出保护，确保工控机环境下的系统安全。
+- **日志分级**：生产环境下仅输出关键业务日志，详细通信日志转入 Debug 级别
+- **智能优先队列**：触发源面板优先处理（500ms优先窗口）
+  - **队列自动处理**：指令自动串行化，避免 RS485 总线冲突
+  - **断连自动恢复**：主站/从站连接断开后支持毫秒级自动重连
+  - **多实例运行**：支持同时运行多个 `Modbus主站` 节点，配置完全隔离
+  - **状态持久化**：Mesh 设备列表和继电器状态在重启后自动恢复
+  - **日志分级**：生产环境下仅输出关键业务日志，详细通信日志转入 Debug 级别
 
 **实际使用场景**：
 - 主站轮询：200ms/台，支持5-10台从站设备

package/nodes/modbus-master.js

@@ -329,9 +329,9 @@ 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`);
 
@@ -384,6 +384,7 @@ module.exports = function(RED) {
 
             } catch (err) {
                 node.isConnected = false;
+                node.writeQueue = []; // 断开连接时清空写入队列，不处理缓存数据
                 
                 // 优化：如果错误消息没有变化，且不是第一次重试，则不输出 node.error 到全局日志
                 // 这样可以避免 ECONNREFUSED 等持续性错误刷屏
@@ -901,17 +902,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 +1065,7 @@ module.exports = function(RED) {
                     }
 
                     node.isConnected = false;
+                    node.writeQueue = []; // 断开连接时清空写入队列，不处理缓存数据
                     // 原则：轮询永不停止，即使连接断开也由 startPolling 的 pollLoop 自动重试
                     // 不再调用 node.stopPolling()，避免轮询线程彻底终止
                     // node.stopPolling();
@@ -1241,6 +1238,11 @@ module.exports = function(RED) {
                 return;
             }
 
+            // 如果未连接，静默退出，等待重连后自动触发，避免断连期间日志刷屏
+            if (!node.isConnected || !node.client || node.isClosing) {
+                return;
+            }
+
             node.isProcessingWrite = true;
 
             try {
@@ -1251,7 +1253,6 @@ module.exports = function(RED) {
                 while (node.writeQueue.length > 0) {
                     // 再次检查连接和客户端，防止处理中途断开
                     if (node.isClosing || !node.isConnected || !node.client) {
-                        node.log('处理写入队列时Modbus断开，等待重连...');
                         break;
                     }
 
@@ -1293,8 +1294,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 +1313,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 +1398,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));
                 }
 
@@ -1436,7 +1427,7 @@ module.exports = function(RED) {
                 node.client.setID(slaveId);
 
                 // 记录写入操作（帮助追踪总线数据来源）
-                node.log(`写入线圈: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
+                node.debug(`[Modbus写入] 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
 
                 await node.client.writeCoil(coil, value);
 
@@ -1447,7 +1438,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.debug(`[Modbus成功] 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
 
                 // 发布到MQTT和触发事件
                 node.publishMqttState(slaveId, coil, value);
@@ -1492,6 +1483,17 @@ module.exports = function(RED) {
         // 写单个线圈（公共接口，通过队列执行）
         node.writeSingleCoil = function(slaveId, coil, value, triggerSource = 'unknown') {
             return new Promise((resolve, reject) => {
+                // 队列去重：如果队列中已经有针对同一从站同一线圈的写入任务，则移除旧任务，只保留最新的
+                // 这能有效防止“连点”导致的队列积压和状态反复跳变
+                node.writeQueue = node.writeQueue.filter(task => {
+                    if (task.type === 'single' && task.slaveId === slaveId && task.coil === coil) {
+                        // 如果任务还未开始执行（在队列中），直接移除，并调用其resolve防止Promise挂起
+                        if (task.resolve) task.resolve(); 
+                        return false;
+                    }
+                    return true;
+                });
+
                 // 添加到队列
                 node.writeQueue.push({
                     type: 'single',
@@ -1519,13 +1521,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));
                 }
 
@@ -1632,29 +1632,45 @@ 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) {
+                node.log(`[免连线联动] 触发写入: 从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'} (触发源: ${triggerSource})`);
+            } 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}`);
             }

package/nodes/modbus-slave-switch.js

@@ -536,9 +536,16 @@ module.exports = function(RED) {
                 // 检查是否是当前面板触发的操作
                 const isTriggerSourcePanel = (node.serialPortConfig && node.serialPortConfig.triggerSource === panelKey);
 
-                // 检查主站关联（如果配置了主站，则只响应对应主站的消息）
+                // 检查主站关联
                 if (node.config.modbusMaster && masterId && node.config.modbusMaster !== masterId) {
-                    return;
+                    // 如果配置了主站但 ID 不匹配，通常应该忽略。
+                    // 但是，如果从站地址和线圈号完全匹配，说明这是我们正在监控的设备状态。
+                    // 在多主站联动场景下，允许接收来自其他主站的状态同步。
+                    if (slave === parseInt(node.config.targetSlaveAddress) && coil === parseInt(node.config.targetCoilNumber)) {
+                        node.debug(`[LED反馈] 接收到来自跨主站(${masterId})的状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                    } else {
+                        return;
+                    }
                 }
 
                 // 检查是否是我们关注的从站和线圈
@@ -574,67 +581,62 @@ 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);
-                                        }
-                                        
-                                        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));
-                                                });
-                                                // 强制 isTriggerSource=false，确保这里发出的都是同步指令
-                                                representativeNode.sendCommandToPanel(representativeNode.currentState, false, changedButtons);
-                                            }
-                                        } else {
-                                            currentTimerObj.targetNodes.forEach(targetNode => {
-                                                targetNode.sendCommandToPanel(targetNode.currentState, false);
+                            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));
                                             });
+                                            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;
                         }
 
@@ -1250,6 +1252,15 @@ 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;
+            }
+
             RED.events.emit('modbus:writeCoil', {
                 slave: node.config.targetSlaveAddress,
                 coil: node.config.targetCoilNumber,
@@ -1257,7 +1268,7 @@ module.exports = function(RED) {
                 source: 'slave-switch',
                 triggerSource: isSceneMode ? 'scene-trigger' : 'button-press',  // 场景模式使用scene-trigger，开关模式使用button-press
                 nodeId: node.id,
-                masterId: node.config.modbusMaster || "", // 指定目标主站ID
+                masterId: targetMasterId, // 指定目标主站ID
                 serialPortConfigId: config.serialPortConfig // 增加串口配置ID，用于主站过滤，防止多主站冲突
             });
 

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