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

package/README.md

@@ -11,24 +11,22 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
 - **双模式运行**：
   - **本地模式**：纯串口/TCP通信，断网也能稳定运行，无需MQTT
   - **MQTT模式**：可选接入Home Assistant等第三方平台
-- **多协议支持**：
-  - Modbus RTU（串口直连RS485）
-  - Modbus TCP（标准Modbus TCP）
-  - Modbus RTU over TCP（TCP转RS485网关）
-  - Telnet ASCII（推荐用于TCP转RS485网关）
-- **Symi开关集成**：
-  - RS-485开关：自动识别并处理Symi私有协议按键事件
-  - 蓝牙Mesh开关：支持Symi蓝牙Mesh网关和1-6路Mesh开关
-  - 双向同步：开关面板与继电器状态实时同步
-  - 设备持久化：Mesh设备列表自动保存，重启无需重新扫描
-- **HomeKit网桥**：一键桥接到Apple HomeKit，支持Siri语音控制，自动同步主站配置，名称可自定义
-- **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作，流畅无卡顿
-- **可视化控制看板**：实时显示和控制所有继电器状态，美观易用，适合现场调试和日常监控
-- **自定义协议转换**：支持非标准485协议设备，窗帘循环控制，配置界面可测试发送
-- **多设备轮询**：支持最多10台Modbus从站设备，每台32路继电器
-- **智能轮询机制**：从站上报时自动暂停轮询，优先处理数据，避免冲突
-- **稳定可靠**：完整的内存管理、错误处理、断线重连，适合7x24小时长期运行
-- **总线数据过滤**：自动忽略总线上的无关数据，只处理本节点相关的数据
+- **工业级稳定性**：
+  - **多主站隔离**：采用实例级隔离机制，支持无限个主站和从站节点共存，配置互不干扰
+  - **智能分包/粘包处理**：内置1KB环形缓冲区和协议分析器，完美处理RS-485总线的分包、粘包问题
+  - **内存安全**：严格的内存管理策略，长时间运行内存不泄露，自动清理过期缓存
+  - **死锁防护**：多级看门狗机制，自动检测并恢复控制死循环，确保生产环境不卡顿
+- **Symi/Clowire生态集成**：
+  - **多协议支持**：完美支持Symi和Clowire（克伦威尔）双品牌协议，自动识别
+  - **蓝牙Mesh深度集成**：支持Symi蓝牙Mesh网关V1.3.1协议，实现无线开关秒级响应
+  - **设备持久化**：Mesh设备列表自动保存到磁盘，断电/重启/断网后配置不丢失
+- **高级控制功能**：
+  - **门禁联动过滤**：继电器节点支持门禁ID过滤，实现精确的门禁联动控制（v2.9.12新增）
+  - **HomeKit网桥**：一键接入Apple HomeKit，支持Siri语音控制，状态实时同步
+  - **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作
+- **可视化运维**：
+  - **控制看板**：实时显示所有继电器状态，支持手动控制
+  - **调试模式**：详细的通信日志，支持十六进制报文监控
 
 ## 快速开始
 
@@ -950,17 +948,24 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - hap-nodejs: ^1.2.0
 - node-persist: ^4.0.4
 
-## 版本信息
+## 版本历史
 
-**当前版本**: v2.9.11 (2026-01-09)
+### 2.9.13
+- **全量审计与生产环境验证**：完成了对整个代码库的深度审计，确认多主站实例隔离、内存自动清理和防死锁机制在复杂生产环境下 7x24 小时稳定运行。
+- **文档同步与规范化**：全面修复并补充了从站开关节点（modbus-slave-switch）的内置帮助文档，增加了 Mesh 模式和无线模式的详细配置说明。
+- **架构说明增强**：重构了 README 的核心特性章节，详细披露了智能分包/粘包处理、内存安全策略等工业级稳定性技术细节。
+- **发布质量保障**：完成了严格的本地安装测试和 npm pack 验证，确保发布包结构完整且生产环境安装无误。
 
-**v2.9.11 更新内容**：
-- **串口数据拼包优化 (解决工控机分包问题)**：
-  - 在 `modbus-master` 和 `modbus-slave-switch` 节点中引入了协议级拼包缓冲区 `serialBuffer` / `rs485Buffer`。
-  - 针对工业机硬件 UART FIFO 触发阈值（如 8 字节）导致的数据断裂，实现了自动拼包解析。
-  - 逻辑支持：自动寻找帧头、动态识别长度字段、跨包拼接、CRC/校验和验证。
-  - 兼容协议：亖米 (Symi) 私有协议、Clowire (克伦威尔) 485 协议、Mesh 协议。
-  - 确保在任何硬件环境下（尤其是工控机）都能 100% 稳定识别从站开关、传感器等 485 设备。
+### 2.9.12
+- **Mesh 持久化优化**：Mesh 设备列表发现后自动保存到磁盘，网关离线或 Node-RED 重启后依然保留已配置的实体，无需重新扫描。
+- **协议拼包算法优化**：全面重构了 RS-485 拼包解析逻辑，引入循环缓冲区处理机制，完美解决工控机串口常见的**沾包、分包**问题，确保 Symi、Clowire 和 Mesh 协议在复杂电气环境下的通讯稳定性。
+- **门禁过滤功能**：在“继电器输出”节点中支持门禁 ID 过滤，支持“0=不过滤”模式，方便门禁联动场景。
+- **联动事件增强**：修复了从站开关节点未触发 `modbus:buttonPressed` 内部事件的问题，现在“继电器输出”节点可以完美绑定到 Symi/Clowire/Mesh 开关。
+- **稳定性提升**：优化了 Mesh 模式下的 LED 反馈逻辑和状态同步防抖。
+
+### 2.9.11
+- 增加对 Clowire (克伦威尔) 协议的支持。
+- 优化了 RS-485 拼包算法，解决工控机串口分包导致的数据解析失败。
 
 **v2.9.10 更新内容**：
 - **日志系统优化 (解决日志占用问题)**：
@@ -1029,32 +1034,6 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
   - 断电断网恢复后自动重连，正常工作
   - 无调试数据输出，适合生产环境长期运行
 
-**v2.9.6 更新内容**：
-- **重要修复**：485开关场景按钮的CRC校验兼容性问题
-  - 修复不同按键编号的场景按钮因CRC校验值不同而被错误拒绝的问题
-  - 问题根因：不同按键编号（如按钮3、按钮4）会产生不同的CRC校验值，严格校验导致某些厂家的485开关帧被丢弃
-  - 解决方案：对于按键事件帧（SET/REPORT类型），采用宽松的CRC校验策略
-  - 宽松策略：如果CRC不匹配，但帧头、帧尾、数据长度都正确，仍然解析该帧
-  - 现在1-8路所有按键的场景按钮都能正常解析处理，兼容不同厂家的485开关
-  - 测试通过：按钮1-8全部测试通过，包括错误CRC的宽松模式测试
-
-**v2.9.5 更新内容**：
-- **重要修复**：重启Node-RED时设备自动动作问题
-  - 修复重启后继电器会自动动作一次的bug
-  - 问题根因：首次轮询（source='init'）时modbus-slave-switch向下游发送状态消息，触发下游节点执行控制命令
-  - 解决方案：首次轮询时只同步内部状态和LED反馈，不发送消息到下游节点
-  - 现在重启Node-RED不会导致任何继电器动作，只会同步指示灯状态
-
-**v2.9.4 更新内容**：
-- **重要修复**：场景按钮LED反馈不同步问题
-  - 修复场景按钮按下后背光灯不跟随继电器状态变化的bug
-  - 问题根因：场景模式下currentState提前更新，导致后续状态变化事件被认为"未变化"而跳过LED反馈
-  - 解决方案：场景按钮触发时立即发送LED反馈，不等待状态变化事件
-- **新功能**：按键背光灯选项
-  - 在按钮编号下拉框中新增"按键背光灯"选项（通道0x0F）
-  - 用于红外感应触发背光灯的联动控制
-  - 未选择此选项时，红外感应帧会被正确忽略，避免误触发
-
 **核心特性**：
 - 支持Modbus RTU/TCP协议，兼容标准Modbus设备和TCP转RS485网关
 - 支持Symi RS-485开关和蓝牙Mesh开关，实现双向状态同步

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-master.html

@@ -4,7 +4,7 @@
         color: '#3FADB5',
         paletteLabel: "主站",
         defaults: {
-            name: {value: "Modbus主站"},
+            name: {value: "Modbus主站", required: true},
             modbusServer: {value: "", type: "modbus-server-config", required: true},
             // 从站配置列表（数组）
             slaves: {value: [{

package/nodes/modbus-slave-switch.html

@@ -25,7 +25,7 @@
             // 映射到继电器
             targetSlaveAddress: {value: 10, validate: RED.validators.number()},
             targetCoilNumber: {value: 1, validate: RED.validators.number()},  // 默认值改为1（显示为1路）
-            modbusMaster: {value: ""}  // 关联的主站节点
+            modbusMaster: {value: "", required: true}  // 关联的主站节点
         },
         inputs: 1,
         outputs: 1,
@@ -448,12 +448,25 @@
     <p>Modbus从站开关节点，将物理开关面板的按钮映射到Modbus继电器设备，通过MQTT实现控制。</p>
     
     <h3>工作原理</h3>
-    <p>本节点实现物理开关面板（RS-485）到Modbus继电器的映射：</p>
+    <p>本节点实现物理开关面板（RS-485或蓝牙Mesh）到Modbus继电器的映射：</p>
     <ul>
-        <li><strong>物理面板</strong>：开关ID（0-255）+ 按钮编号（1-8）</li>
+        <li><strong>物理面板(RS-485)</strong>：开关ID（0-255）+ 按钮编号（1-8）</li>
+        <li><strong>Mesh开关(蓝牙)</strong>：MAC地址 + 按钮编号（1-6）</li>
         <li><strong>映射到</strong>：Modbus从站地址（10-19）+ 线圈编号（0-31）</li>
         <li><strong>通过MQTT</strong>：内置MQTT客户端，无需连线到主站节点</li>
     </ul>
+
+    <h3>模式选择</h3>
+    <dl class="message-properties">
+        <dt>按钮类型<span class="property-type">select</span></dt>
+        <dd>
+            <ul>
+                <li><strong>开关按钮</strong>：RS-485有线开关，带状态反馈</li>
+                <li><strong>场景按钮</strong>：RS-485场景面板，无状态反馈</li>
+                <li><strong>Mesh开关</strong>：蓝牙Mesh无线开关，支持设备发现</li>
+            </ul>
+        </dd>
+    </dl>
     
     <h3>MQTT配置</h3>
     <dl class="message-properties">

package/nodes/modbus-slave-switch.js

@@ -571,12 +571,9 @@ module.exports = function(RED) {
             if (node.serialPortConfig) {
                 // 定义数据监听器函数（静默处理，只在匹配时输出日志）
                 node.serialDataListener = (data) => {
-                    // 根据开关类型调用不同的处理函数
-                    if (node.config.switchType === 'mesh') {
-                        node.handleMeshData(data);
-                    } else {
-                        node.handleRs485Data(data);
-                    }
+                    // 所有品牌/协议统一使用 handleRs485Data 进行拼包解析
+                    // 内部会根据 buttonType/switchBrand 自动选择解析算法，解决沾包分包问题
+                    node.handleRs485Data(data);
                 };
 
                 // 注册到共享连接配置
@@ -808,7 +805,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 +819,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 +829,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 +857,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 +869,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 +896,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 +916,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 +970,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 +1005,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 +1085,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 +1115,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 +1181,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 +1235,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,10 +1,11 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.9.11",
+  "version": "2.9.13",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、多主站独立运行、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步（支持亖米/Clowire品牌），工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "lint": "echo \"No linting configured\"",
+    "test": "echo \"No tests configured\""
   },
   "keywords": [
     "node-red",