node-red-contrib-symi-modbus 2.9.11 → 2.9.12

package/README.md

@@ -950,17 +950,17 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - hap-nodejs: ^1.2.0
 - node-persist: ^4.0.4
 
-## 版本信息
+## 版本历史
 
-**当前版本**: v2.9.11 (2026-01-09)
+### 2.9.12
+- **Mesh 持久化优化**：Mesh 设备列表发现后自动保存到磁盘，网关离线或 Node-RED 重启后依然保留已配置的实体，无需重新扫描。
+- **门禁过滤功能**：在“继电器输出”节点中支持门禁 ID 过滤，支持“0=不过滤”模式，方便门禁联动场景。
+- **联动事件增强**：修复了从站开关节点未触发 `modbus:buttonPressed` 内部事件的问题，现在“继电器输出”节点可以完美绑定到 Symi/Clowire/Mesh 开关。
+- **稳定性提升**：优化了 Mesh 模式下的 LED 反馈逻辑和状态同步防抖。
 
-**v2.9.11 更新内容**：
-- **串口数据拼包优化 (解决工控机分包问题)**：
-  - 在 `modbus-master` 和 `modbus-slave-switch` 节点中引入了协议级拼包缓冲区 `serialBuffer` / `rs485Buffer`。
-  - 针对工业机硬件 UART FIFO 触发阈值（如 8 字节）导致的数据断裂，实现了自动拼包解析。
-  - 逻辑支持：自动寻找帧头、动态识别长度字段、跨包拼接、CRC/校验和验证。
-  - 兼容协议：亖米 (Symi) 私有协议、Clowire (克伦威尔) 485 协议、Mesh 协议。
-  - 确保在任何硬件环境下（尤其是工控机）都能 100% 稳定识别从站开关、传感器等 485 设备。
+### 2.9.11
+- 增加对 Clowire (克伦威尔) 协议的支持。
+- 优化了 RS-485 拼包算法，解决工控机串口分包导致的数据解析失败。
 
 **v2.9.10 更新内容**：
 - **日志系统优化 (解决日志占用问题)**：

package/nodes/clowire-protocol.js

@@ -193,6 +193,29 @@ module.exports = {
         return buffer;
     },
     
+    /**
+     * 判断是否是有效的 Clowire 协议帧
+     * @param {Buffer} buffer - 接收到的数据
+     * @returns {boolean} 是否有效
+     */
+    isClowireFrame: function(buffer) {
+        if (!buffer || buffer.length < 9) return false;
+        if (buffer[buffer.length - 1] !== this.FRAME_TAIL) return false;
+        
+        // 验证CRC16
+        const dataLen = buffer.length - 3;
+        const receivedCRC = buffer[dataLen] | (buffer[dataLen + 1] << 8);
+        const calculatedCRC = this.calculateCRC16(buffer, dataLen);
+        
+        if (receivedCRC === calculatedCRC) return true;
+        
+        // 宽松模式：如果是按键事件帧，允许CRC不匹配
+        const cmdCode = buffer[1];
+        const isButtonEvent = (cmdCode === this.CMD_BUTTON_EVENT || cmdCode === this.CMD_READ);
+        
+        return isButtonEvent;
+    },
+
     /**
      * 解析接收到的协议帧
      * @param {Buffer} buffer - 接收到的数据
@@ -288,10 +311,12 @@ module.exports = {
             
             // 提取帧
             const frameBuffer = buffer.slice(offset, endIndex + 1);
-            const frame = this.parseFrame(frameBuffer);
             
-            if (frame) {
-                frames.push(frame);
+            if (this.isClowireFrame(frameBuffer)) {
+                const frame = this.parseFrame(frameBuffer);
+                if (frame) {
+                    frames.push(frame);
+                }
             }
             
             offset = endIndex + 1;

package/nodes/homekit-bridge.js

@@ -227,7 +227,8 @@ module.exports = function(RED) {
                 slave: slaveAddr,
                 coil: coil,
                 value: value,
-                source: 'homekit'
+                source: 'homekit',
+                masterId: node.config.masterNodeId
             });
             
             node.log(`HomeKit控制: 从站${slaveAddr} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);

package/nodes/lightweight-protocol.js

@@ -315,6 +315,36 @@ module.exports = {
      * @param {Buffer} buffer - 接收到的数据（可能包含多个帧）
      * @returns {Array} 解析出的所有帧数组
      */
+    /**
+     * 判断是否是有效的亖米协议帧
+     * @param {Buffer} buffer - 接收到的数据
+     * @returns {boolean} 是否有效
+     */
+    isSymiFrame: function(buffer) {
+        if (!buffer || buffer.length < 15) return false;
+        if (buffer[0] !== this.FRAME_HEADER) return false;
+        if (buffer[buffer.length - 1] !== this.FRAME_TAIL) return false;
+        
+        const dataLen = buffer[3];
+        if (buffer.length !== dataLen) return false;
+        
+        // 校验和验证
+        const receivedCRC = buffer[buffer.length - 2];
+        const calculatedCRC = this.calculateCRC8(buffer, buffer.length);
+        
+        if (receivedCRC === calculatedCRC) return true;
+        
+        // 宽松模式：如果是按键事件帧，允许CRC不匹配
+        const dataType = buffer[2];
+        const deviceType = buffer[4];
+        const opCode = buffer.length > 11 ? buffer[11] : 0;
+        const isButtonEvent = (dataType === 0x03 || dataType === 0x04) && 
+                              (deviceType === 0x01 || deviceType === 0x07) && 
+                              opCode === 0x00;
+                              
+        return isButtonEvent;
+    },
+
     parseAllFrames: function(buffer) {
         const frames = [];
         if (!buffer || buffer.length < 15) {
@@ -362,61 +392,34 @@ module.exports = {
             // 提取帧数据
             const frameBuffer = buffer.slice(startIndex, startIndex + dataLen);
             
-            // 检查帧尾
-            if (frameBuffer[frameBuffer.length - 1] !== this.FRAME_TAIL) {
-                offset = startIndex + 1; // 跳过继续搜索
-                continue;
-            }
-            
-            // 验证CRC（采用宽松策略）
-            const receivedCRC = frameBuffer[frameBuffer.length - 2];
-            const calculatedCRC = this.calculateCRC8(frameBuffer, frameBuffer.length);
-            
-            // 判断是否是按键事件帧（与parseFrame保持一致）
-            const dataType = frameBuffer[2];
-            const deviceType = frameBuffer[4];
-            const opCode = frameBuffer.length > 11 ? frameBuffer[11] : 0;
-            const isButtonEvent = (dataType === 0x03 || dataType === 0x04) && 
-                                  (deviceType === 0x01 || deviceType === 0x07) && 
-                                  opCode === 0x00;
-            
-            if (receivedCRC !== calculatedCRC) {
-                // CRC校验失败
-                // 如果是按键事件帧，且帧头、帧尾、数据长度都正确，则采用宽松策略继续解析
-                if (isButtonEvent && 
-                    frameBuffer[0] === this.FRAME_HEADER && 
-                    frameBuffer[frameBuffer.length - 1] === this.FRAME_TAIL && 
-                    frameBuffer[3] === dataLen) {
-                    // 宽松模式：允许CRC不匹配的按键事件帧通过
-                } else {
-                    offset = startIndex + 1; // 非按键事件，CRC错误，跳过继续搜索
-                    continue;
+            // 验证帧有效性
+            if (this.isSymiFrame(frameBuffer)) {
+                // 解析帧
+                const frame = {
+                    localAddr: frameBuffer[1],
+                    dataType: frameBuffer[2],
+                    dataLen: frameBuffer[3],
+                    deviceType: frameBuffer[4],
+                    brandID: frameBuffer[5],
+                    deviceAddr: frameBuffer[6],
+                    channel: frameBuffer[7],
+                    roomNo: frameBuffer[8],
+                    roomType: frameBuffer[9],
+                    roomID: frameBuffer[10],
+                    opCode: frameBuffer[11],
+                    opInfo: []
+                };
+                
+                // 提取操作信息
+                for (let i = 12; i < frameBuffer.length - 2; i++) {
+                    frame.opInfo.push(frameBuffer[i]);
                 }
+                
+                frames.push(frame);
+                offset = startIndex + dataLen;
+            } else {
+                offset = startIndex + 1; // 无效帧，跳过继续搜索
             }
-            
-            // 解析帧
-            const frame = {
-                localAddr: frameBuffer[1],
-                dataType: frameBuffer[2],
-                dataLen: frameBuffer[3],
-                deviceType: frameBuffer[4],
-                brandID: frameBuffer[5],
-                deviceAddr: frameBuffer[6],
-                channel: frameBuffer[7],
-                roomNo: frameBuffer[8],
-                roomType: frameBuffer[9],
-                roomID: frameBuffer[10],
-                opCode: frameBuffer[11],
-                opInfo: []
-            };
-            
-            // 提取操作信息
-            for (let i = 12; i < frameBuffer.length - 2; i++) {
-                frame.opInfo.push(frameBuffer[i]);
-            }
-            
-            frames.push(frame);
-            offset = startIndex + dataLen; // 移动到下一帧
         }
         
         return frames;

package/nodes/mesh-protocol.js

@@ -332,9 +332,85 @@ module.exports = function(RED) {
         return stateValue;
     }
 
+    /**
+     * 判断是否是有效的Mesh帧
+     * @param {Buffer} buffer - 接收到的数据
+     * @returns {boolean} 是否有效
+     */
+    function isMeshFrame(buffer) {
+        if (!buffer || buffer.length < 5) return false;
+        if (buffer[0] !== PROTOCOL.HEADER) return false;
+        
+        const dataLen = buffer[3];
+        const totalLen = 4 + dataLen + 1;
+        
+        if (buffer.length !== totalLen) return false;
+        
+        // 校验和验证
+        const receivedChecksum = buffer[buffer.length - 1];
+        const calculatedChecksum = calculateChecksum(buffer.slice(0, buffer.length - 1));
+        
+        return receivedChecksum === calculatedChecksum;
+    }
+
+    /**
+     * 解析所有Mesh协议帧（处理粘包）
+     * @param {Buffer} buffer - 接收到的数据（可能包含多个帧）
+     * @returns {Array} 解析出的所有事件数组
+     */
+    function parseAllFrames(buffer) {
+        const events = [];
+        if (!buffer || buffer.length < 5) return events;
+
+        let offset = 0;
+        let maxIterations = 10;
+
+        while (offset < buffer.length && maxIterations > 0) {
+            maxIterations--;
+
+            // 查找帧头
+            const headerIndex = buffer.indexOf(PROTOCOL.HEADER, offset);
+            if (headerIndex === -1) break;
+
+            // 更新偏移量到帧头
+            offset = headerIndex;
+
+            // 检查剩余长度是否足够读取长度字节
+            if (buffer.length - offset < 4) break;
+
+            const dataLen = buffer[offset + 3];
+            const totalLen = 4 + dataLen + 1;
+
+            // 检查非法长度（Mesh帧通常不会太大）
+            if (totalLen > 64 || totalLen < 5) {
+                offset++;
+                continue;
+            }
+
+            // 检查剩余数据是否足够一个完整帧
+            if (buffer.length - offset < totalLen) break;
+
+            const frameBuffer = buffer.slice(offset, offset + totalLen);
+            
+            // 验证帧有效性
+            if (isMeshFrame(frameBuffer)) {
+                const event = parseStatusEvent(frameBuffer);
+                if (event) {
+                    events.push(event);
+                }
+            }
+
+            offset += totalLen;
+        }
+
+        return events;
+    }
+
     return {
         PROTOCOL,
         calculateChecksum,
+        isMeshFrame,
+        parseAllFrames,
         buildGetDeviceListFrame,
         parseDeviceListResponse,
         buildSwitchControlFrame,

package/nodes/modbus-dashboard.html

@@ -134,7 +134,7 @@
                             var newState = !currentState;
 
                             // 发送控制命令（通过HTTP API）
-                            sendControlCommand(slaveAddr, coil, newState);
+                            sendControlCommand(slaveAddr, coil, newState, masterNodeId);
 
                             // 立即更新UI（乐观更新）
                             stateCache[key] = newState;
@@ -159,7 +159,7 @@
             }
 
             // 发送控制命令
-            function sendControlCommand(slaveAddr, coil, value) {
+            function sendControlCommand(slaveAddr, coil, value, masterNodeId) {
                 // 通过Node-RED的admin API发送注入命令
                 $.ajax({
                     url: '/modbus-dashboard/control',
@@ -168,7 +168,8 @@
                     data: JSON.stringify({
                         slave: slaveAddr,
                         coil: coil,
-                        value: value
+                        value: value,
+                        masterNodeId: masterNodeId
                     }),
                     success: function() {
                         console.log(`控制命令已发送: 从站${slaveAddr} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);

package/nodes/modbus-dashboard.js

@@ -155,6 +155,7 @@ module.exports = function(RED) {
         var slave = parseInt(req.body.slave);
         var coil = parseInt(req.body.coil);
         var value = Boolean(req.body.value);
+        var masterNodeId = req.body.masterNodeId;
 
         if (isNaN(slave) || isNaN(coil)) {
             res.status(400).json({error: '参数错误'});
@@ -166,7 +167,8 @@ module.exports = function(RED) {
             slave: slave,
             coil: coil,
             value: value,
-            source: 'dashboard'
+            source: 'dashboard',
+            masterId: masterNodeId
         });
 
         // 立即更新缓存（乐观更新）

package/nodes/modbus-slave-switch.js

@@ -572,7 +572,7 @@ module.exports = function(RED) {
                 // 定义数据监听器函数（静默处理，只在匹配时输出日志）
                 node.serialDataListener = (data) => {
                     // 根据开关类型调用不同的处理函数
-                    if (node.config.switchType === 'mesh') {
+                    if (node.config.buttonType === 'mesh') {
                         node.handleMeshData(data);
                     } else {
                         node.handleRs485Data(data);
@@ -808,7 +808,6 @@ module.exports = function(RED) {
                 // 根据品牌/类型选择不同的拼包解析逻辑
                 if (node.config.buttonType === 'mesh') {
                     // Mesh 协议拼包逻辑
-                    // 最小帧长约5字节: [53][op][sub][len]...[check]
                     while (node.rs485Buffer.length >= 5) {
                         const headerIndex = node.rs485Buffer.indexOf(0x53);
                         if (headerIndex === -1) {
@@ -823,7 +822,7 @@ module.exports = function(RED) {
                         const dataLen = node.rs485Buffer[3];
                         const totalLen = 4 + dataLen + 1; // [53][op][sub][len] + [data...] + [check]
 
-                        if (totalLen > 64) { // 非法长度
+                        if (totalLen > 64 || totalLen < 5) { // 非法长度
                             node.rs485Buffer = node.rs485Buffer.slice(1);
                             continue;
                         }
@@ -833,23 +832,26 @@ module.exports = function(RED) {
                         const completeFrame = node.rs485Buffer.slice(0, totalLen);
                         node.rs485Buffer = node.rs485Buffer.slice(totalLen);
                         
-                        // 处理解析出来的完整Mesh帧
-                        node.handleMeshData(completeFrame);
+                        // 验证帧有效性并解析
+                        if (meshProtocol.isMeshFrame(completeFrame)) {
+                            const event = meshProtocol.parseStatusEvent(completeFrame);
+                            if (event) {
+                                node.handleMeshData(event);
+                            }
+                        }
                     }
                 } else if (node.config.switchBrand === 'clowire') {
                     // Clowire 协议拼包逻辑 (克伦威尔)
-                    // 特点：以 0xAA 结尾，长度通常为 9 或 11 字节
                     while (node.rs485Buffer.length >= 9) {
+                        // Clowire 帧以 0xAA 结尾，且长度固定为 9 或 11
                         const endIndex = node.rs485Buffer.indexOf(0xAA);
                         if (endIndex === -1) {
-                            // 如果缓冲区太长且没找到结尾，保留一部分可能的数据
                             if (node.rs485Buffer.length > 32) {
                                 node.rs485Buffer = node.rs485Buffer.slice(-16);
                             }
                             break;
                         }
 
-                        // 尝试匹配可能的长度
                         let foundFrame = false;
                         const possibleLengths = [9, 11];
 
@@ -858,8 +860,10 @@ module.exports = function(RED) {
                             if (startIndex >= 0) {
                                 const completeFrame = node.rs485Buffer.slice(startIndex, endIndex + 1);
                                 if (clowireProtocol.isClowireFrame(completeFrame)) {
-                                    node.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
+                                    // 找到有效帧，处理它
                                     node.handleClowireData(completeFrame);
+                                    // 移除到当前帧结束的所有数据
+                                    node.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
                                     foundFrame = true;
                                     break;
                                 }
@@ -868,12 +872,11 @@ module.exports = function(RED) {
 
                         if (foundFrame) continue;
 
-                        // 没找到有效帧，跳过当前的 0xAA
+                        // 没找到有效帧，跳过当前的 0xAA，继续寻找下一个
                         node.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
                     }
                 } else {
                     // 亖米 (Symi) 协议拼包逻辑
-                    // 格式: 7E [addr] [type] [len] ... [tail:7D]
                     while (node.rs485Buffer.length >= 15) {
                         const headerIndex = node.rs485Buffer.indexOf(0x7E);
                         if (headerIndex === -1) {
@@ -896,17 +899,14 @@ module.exports = function(RED) {
                         const completeFrame = node.rs485Buffer.slice(0, frameLen);
                         node.rs485Buffer = node.rs485Buffer.slice(frameLen);
 
-                        // 验证尾部
-                        if (completeFrame[completeFrame.length - 1] !== 0x7D) {
-                            // 尾部不匹配，说明不是有效帧
-                            continue;
-                        }
-
-                        // 亖米协议：使用parseAllFrames处理粘包，解析所有帧
-                        const frames = protocol.parseAllFrames(completeFrame);
-                        if (frames && frames.length > 0) {
-                            for (const frame of frames) {
-                                node.processSymiFrame(frame);
+                        // 验证帧有效性
+                        if (protocol.isSymiFrame(completeFrame)) {
+                            // 亖米协议：解析所有可能的子帧
+                            const frames = protocol.parseAllFrames(completeFrame);
+                            if (frames && frames.length > 0) {
+                                for (const frame of frames) {
+                                    node.processSymiFrame(frame);
+                                }
                             }
                         }
                     }
@@ -919,6 +919,18 @@ module.exports = function(RED) {
         // 提取原 handleRs485Data 中的亖米协议处理逻辑
         node.processSymiFrame = function(frame) {
             try {
+                if (!frame) return;
+
+                // 如果传入的是Buffer，则尝试解析
+                if (Buffer.isBuffer(frame)) {
+                    const frames = protocol.parseAllFrames(frame);
+                    if (frames && frames.length > 0) {
+                        for (const f of frames) {
+                            node.processSymiFrame(f);
+                        }
+                    }
+                    return;
+                }
                 // 忽略 REPORT (0x04) 类型的帧
                 if (frame.dataType === 0x04) {
                     return;
@@ -961,10 +973,30 @@ module.exports = function(RED) {
                     if (isSceneMode) {
                         node.debug(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber} (opInfo=0x${buttonEvent.opInfo.toString(16).toUpperCase()})`);
                         node.currentState = !node.currentState;
+                        
+                        // 发送按键按下事件（用于relay-output等节点绑定）
+                        RED.events.emit('modbus:buttonPressed', {
+                            switchId: node.config.switchId,
+                            button: node.config.buttonNumber,
+                            value: node.currentState,
+                            brand: 'symi',
+                            type: 'scene'
+                        });
+
                         node.sendMqttCommand(node.currentState);
                         node.sendCommandToPanel(node.currentState);
                     } else {
                         node.debug(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
+                        
+                        // 发送按键按下事件（用于relay-output等节点绑定）
+                        RED.events.emit('modbus:buttonPressed', {
+                            switchId: node.config.switchId,
+                            button: node.config.buttonNumber,
+                            value: buttonEvent.state,
+                            brand: 'symi',
+                            type: 'switch'
+                        });
+
                         node.sendMqttCommand(buttonEvent.state);
                     }
                 }
@@ -976,13 +1008,15 @@ module.exports = function(RED) {
         // 处理Clowire协议数据
         node.handleClowireData = function(data) {
             try {
-                // 检查是否是Clowire协议帧
-                if (!clowireProtocol.isClowireFrame(data)) {
-                    return; // 静默忽略非Clowire帧
+                let frames = [];
+                if (Buffer.isBuffer(data)) {
+                    // 如果是Buffer，则解析所有帧
+                    frames = clowireProtocol.parseAllFrames(data);
+                } else {
+                    // 如果已经是解析后的帧
+                    frames = [data];
                 }
 
-                // 解析所有帧
-                const frames = clowireProtocol.parseAllFrames(data);
                 if (!frames || frames.length === 0) {
                     return;
                 }
@@ -1054,6 +1088,16 @@ module.exports = function(RED) {
 
                         // 所有按键事件都当作单击处理：切换状态
                         node.currentState = !node.currentState;
+
+                        // 发送按键按下事件（用于relay-output等节点绑定）
+                        RED.events.emit('modbus:buttonPressed', {
+                            switchId: node.config.switchId,
+                            button: node.config.buttonNumber,
+                            value: node.currentState,
+                            brand: 'clowire',
+                            type: 'switch'
+                        });
+
                         node.sendMqttCommand(node.currentState);
 
                         // 输出消息
@@ -1074,12 +1118,16 @@ module.exports = function(RED) {
         };
 
         // 处理Mesh协议数据
-        node.handleMeshData = function(data) {
+        node.handleMeshData = function(event) {
             try {
-                // 解析Mesh状态事件
-                const event = meshProtocol.parseStatusEvent(data);
                 if (!event) {
-                    return; // 静默忽略无效帧
+                    return;
+                }
+                
+                // 如果传入的是Buffer，则尝试解析
+                if (Buffer.isBuffer(event)) {
+                    event = meshProtocol.parseStatusEvent(event);
+                    if (!event) return;
                 }
 
                 // 检查是否是我们监听的Mesh设备
@@ -1136,6 +1184,15 @@ module.exports = function(RED) {
 
                     node.debug(`[Mesh场景] 设备${meshAddr} 按键${node.config.meshButtonNumber} 触发继电器控制: ${buttonState}`);
 
+                    // 发送按键按下事件（用于relay-output等节点绑定）
+                    RED.events.emit('modbus:buttonPressed', {
+                        switchId: node.config.meshShortAddress, // Mesh使用短地址作为switchId
+                        button: node.config.meshButtonNumber,
+                        value: buttonState,
+                        brand: 'mesh',
+                        type: 'scene'
+                    });
+
                     // 跳过后续的状态缓存检查，直接发送继电器控制命令
                 } else {
                     // 开关模式：正常处理LED反馈锁和状态缓存
@@ -1181,6 +1238,15 @@ module.exports = function(RED) {
                     previousStates[node.config.meshButtonNumber - 1] = buttonState;
                     meshDeviceStates.set(meshAddr, previousStates);
                     node.debug(`[Mesh按键] 设备${meshAddr} 按键${node.config.meshButtonNumber} 状态变化: ${previousButtonState} → ${buttonState}`);
+                    
+                    // 发送按键按下事件（用于relay-output等节点绑定）
+                    RED.events.emit('modbus:buttonPressed', {
+                        switchId: node.config.meshShortAddress,
+                        button: node.config.meshButtonNumber,
+                        value: buttonState,
+                        brand: 'mesh',
+                        type: 'switch'
+                    });
                 }
 
                 // 初始化期间不发送控制命令（避免重启时Mesh开关状态覆盖继电器状态）

package/nodes/relay-output.html

@@ -5,6 +5,8 @@
         paletteLabel: "继电器输出",
         defaults: {
             name: { value: "" },
+            // 目标主站节点
+            masterNode: { value: "", required: true },
             // RS-485连接配置（共享配置节点）
             serialPortConfig: { value: "", type: "serial-port-config", required: false },
             // 物理开关面板配置（触发源）
@@ -37,6 +39,34 @@
         oneditprepare: function() {
             const node = this;
 
+            // 填充主站节点选择器
+            var masterNodeSelect = $("#node-input-masterNode");
+            masterNodeSelect.empty();
+            masterNodeSelect.append('<option value="">请选择主站节点</option>');
+
+            // 查找所有modbus-master节点
+            var masters = [];
+            RED.nodes.eachNode(function(n) {
+                if (n.type === "modbus-master") {
+                    masters.push(n);
+                }
+            });
+            
+            masters.sort(function(a, b) {
+                return (a.name || "").localeCompare(b.name || "");
+            });
+
+            masters.forEach(function(n) {
+                var label = n.name || `主站 ${n.id.substring(0, 8)}`;
+                var selected = (n.id === node.masterNode) ? ' selected' : '';
+                masterNodeSelect.append(`<option value="${n.id}"${selected}>${label}</option>`);
+            });
+
+            // 如果当前没有主站节点，显示提示
+            if (masters.length === 0) {
+                masterNodeSelect.append('<option value="" disabled>未找到主站节点，请先添加主站</option>');
+            }
+
             // 延时提示
             $("#node-input-delayMs").on("change", function() {
                 var val = parseInt($(this).val()) || 0;
@@ -76,6 +106,13 @@
                 var action = $("#node-input-action").val() || 'on';
                 var delay = parseInt($("#node-input-delayMs").val()) || 0;
                 var buttonType = $("#node-input-buttonType").val();
+                var masterNodeId = $("#node-input-masterNode").val();
+                
+                var masterLabel = "未选择主站";
+                if (masterNodeId) {
+                    var masterNode = RED.nodes.node(masterNodeId);
+                    masterLabel = masterNode ? (masterNode.name || `主站 ${masterNodeId.substring(0, 8)}`) : "未知主站";
+                }
                 
                 const actionMap = { 'on': '打开', 'off': '关闭', 'follow': '跟随', 'toggle': '翻转' };
                 const btnLabel = btnNum == 15 ? '背光灯' : `按钮${btnNum}`;
@@ -85,10 +122,10 @@
                     : `开关${switchId}-${btnLabel}`;
                 var delayText = delay > 0 ? `, 延时${delay}ms` : '';
                 
-                $("#config-summary").html(`<strong>${triggerText}</strong> → 继电器${slave}-${coil}路 <strong>${actionMap[action]}</strong>${delayText}`);
+                $("#config-summary").html(`[${masterLabel}] <strong>${triggerText}</strong> → 继电器${slave}-${coil}路 <strong>${actionMap[action]}</strong>${delayText}`);
             }
             
-            $("#node-input-switchId, #node-input-buttonNumber, #node-input-slaveAddress, #node-input-coilNumber, #node-input-action, #node-input-delayMs, #node-input-buttonType").on("change", updateSummary);
+            $("#node-input-switchId, #node-input-buttonNumber, #node-input-slaveAddress, #node-input-coilNumber, #node-input-action, #node-input-delayMs, #node-input-buttonType, #node-input-masterNode").on("change", updateSummary);
             updateSummary();
         }
     });
@@ -198,6 +235,16 @@
         </label>
     </div>
     
+    <div class="form-row">
+        <label for="node-input-masterNode" style="width: 110px;"><i class="fa fa-microchip"></i> 主站节点</label>
+        <select id="node-input-masterNode" style="width: calc(70% - 110px);">
+            <option value="">请选择主站节点</option>
+        </select>
+        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
+            选择要控制的目标Modbus主站节点
+        </div>
+    </div>
+    
     <div class="form-row">
         <label for="node-input-slaveAddress" style="width: 110px;"><i class="fa fa-map-marker"></i> 从站地址</label>
         <input type="number" id="node-input-slaveAddress" placeholder="10" min="1" max="247" style="width: 90px; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">

package/nodes/relay-output.js

@@ -23,6 +23,7 @@ module.exports = function(RED) {
         node.filterDeviceId = parseInt(config.filterDeviceId) || 0;  // 0=不过滤，>0=只响应指定门禁ID
         
         // 配置参数 - 目标继电器
+        node.masterNodeId = config.masterNode;
         node.name = config.name || '';
         node.slaveAddress = parseInt(config.slaveAddress) || 10;
         node.coilNumber = parseInt(config.coilNumber) || 1;
@@ -102,6 +103,7 @@ module.exports = function(RED) {
                 coil: coilIndex,
                 value: value,
                 source: 'relay-output',
+                masterId: node.masterNodeId,
                 nodeId: node.id
             });
 

package/nodes/serial-port-config.js

@@ -402,6 +402,21 @@ module.exports = function(RED) {
 
         // 写入数据（带队列机制，防止并发冲突，支持优先级）
         node.write = function(data, callback, priority, switchId) {
+            // 限制队列长度，防止异常堆积导致内存溢出
+            if (node.writeQueue.length > 500) {
+                const err = new Error('写入队列已满，抛弃旧指令');
+                node.log(err.message);
+                // 抛弃队列中最早的10个普通优先级指令
+                let removed = 0;
+                for (let i = 0; i < node.writeQueue.length && removed < 10; i++) {
+                    if (node.writeQueue[i].priority === 0) {
+                        node.writeQueue.splice(i, 1);
+                        i--;
+                        removed++;
+                    }
+                }
+            }
+
             // 加入写入队列
             const queueItem = { data, callback, priority: priority || 0, switchId };
 

package/package.json

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