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

package/README.md

@@ -950,12 +950,20 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - hap-nodejs: ^1.2.0
 - node-persist: ^4.0.4
 
-## 版本信息
+## 版本历史
 
-**当前版本**: v2.9.10 (2026-01-08)
+### 2.9.12
+- **Mesh 持久化优化**：Mesh 设备列表发现后自动保存到磁盘，网关离线或 Node-RED 重启后依然保留已配置的实体，无需重新扫描。
+- **门禁过滤功能**：在“继电器输出”节点中支持门禁 ID 过滤，支持“0=不过滤”模式，方便门禁联动场景。
+- **联动事件增强**：修复了从站开关节点未触发 `modbus:buttonPressed` 内部事件的问题，现在“继电器输出”节点可以完美绑定到 Symi/Clowire/Mesh 开关。
+- **稳定性提升**：优化了 Mesh 模式下的 LED 反馈逻辑和状态同步防抖。
+
+### 2.9.11
+- 增加对 Clowire (克伦威尔) 协议的支持。
+- 优化了 RS-485 拼包算法，解决工控机串口分包导致的数据解析失败。
 
 **v2.9.10 更新内容**：
-- **日志系统优化（解决日志占用问题）**：
+- **日志系统优化 (解决日志占用问题)**：
   - **彻底静默重连日志**：将 TCP/串口连接过程中的 `node.error` 降级为 `node.log` 或 `node.debug`，不再发送到 Node-RED 调试面板（Debug Tab），彻底解决重连期间日志刷屏问题。
   - **智能过滤**：相同的连接错误在重试期间不再重复输出日志（每 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-master.js

@@ -1161,73 +1161,99 @@ module.exports = function(RED) {
             // 这样可以确保每个从站都按照正确的间隔轮询
         };
         
-        // 处理Symi按键事件（私有协议）
-        // 静默处理：只处理本节点相关的数据，忽略总线上的其他数据
+        // 初始化拼包缓冲区
+        node.serialBuffer = Buffer.alloc(0);
+
+        // 处理Symi按键事件（私有协议）- 增加拼包支持
         node.handleSymiButtonEvent = function(data) {
             try {
-                // 解析Symi协议帧（带CRC校验）
-                const frame = protocol.parseFrame(data);
-                if (!frame) {
-                    // 不是有效的Symi帧（CRC校验失败或格式错误），静默忽略
-                    return;
-                }
+                // 将新数据拼接到缓冲区
+                node.serialBuffer = Buffer.concat([node.serialBuffer, data]);
 
-                // 只处理SET类型(0x03)的按键事件，忽略REPORT类型(0x04)
-                // REPORT类型是面板对我们指令的确认，不是按键事件
-                if (frame.dataType !== 0x03) {
-                    // 不是按键事件，静默忽略
-                    return;
+                // 限制缓冲区大小，防止异常情况下内存溢出（最大1KB）
+                if (node.serialBuffer.length > 1024) {
+                    node.serialBuffer = node.serialBuffer.slice(-1024);
                 }
 
-                // 检查是否是灯光设备
-                if (frame.deviceType !== 0x01) {
-                    // 不是灯光设备，静默忽略
-                    return;
-                }
+                // 循环处理缓冲区中的所有完整帧
+                while (node.serialBuffer.length >= 15) {
+                    // 查找帧头 0x7E
+                    const startIndex = node.serialBuffer.indexOf(0x7E);
+                    if (startIndex === -1) {
+                        // 没找到帧头，清空缓冲区
+                        node.serialBuffer = Buffer.alloc(0);
+                        break;
+                    }
 
-                // 提取按键信息
-                const deviceAddr = frame.deviceAddr;  // 设备地址（1-255）
-                const channel = frame.channel;        // 通道号（1-8）
-                const state = frame.opInfo[0] === 0x01; // 状态（1=开，0=关）
-
-                // 查找对应的从站和线圈
-                // 假设：设备地址1对应从站10，设备地址2对应从站11，以此类推
-                // 通道号直接对应线圈号（1-8 → 0-7）
-                const slaveId = 10 + (deviceAddr - 1);
-                const coilNumber = channel - 1;
-
-                // 检查从站是否在配置中
-                const slaveConfig = node.config.slaves.find(s => s.address === slaveId);
-                if (!slaveConfig) {
-                    // 从站未配置，静默忽略（不是本节点的数据）
-                    return;
-                }
+                    // 如果帧头不在开始位置，丢弃前面的垃圾数据
+                    if (startIndex > 0) {
+                        node.serialBuffer = node.serialBuffer.slice(startIndex);
+                    }
 
-                // 检查线圈是否在范围内
-                if (coilNumber < slaveConfig.coilStart || coilNumber > slaveConfig.coilEnd) {
-                    // 线圈不在范围内，静默忽略（不是本节点的数据）
-                    return;
-                }
+                    // 再次检查剩余长度是否足够解析长度字段（至少4字节）
+                    if (node.serialBuffer.length < 4) break;
+
+                    // 获取协议声明的整帧长度（第4个字节）
+                    const frameLen = node.serialBuffer[3];
+                    
+                    // 验证长度合理性 (Symi协议最小15字节，最大一般不超过64)
+                    if (frameLen < 15 || frameLen > 64) {
+                        // 长度非法，丢弃这个错误的帧头，继续找下一个
+                        node.serialBuffer = node.serialBuffer.slice(1);
+                        continue;
+                    }
 
-                // 到这里说明是本节点的数据，输出日志
-                node.debug(`Symi按键事件: 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
-                node.debug(`Symi按键映射: 设备${deviceAddr}通道${channel} → 从站${slaveId}线圈${coilNumber}`);
+                    // 检查缓冲区数据是否已经达到完整帧长度
+                    if (node.serialBuffer.length < frameLen) {
+                        // 数据还没到齐，跳出循环等待下一波数据
+                        break;
+                    }
 
-                // 写入线圈（异步，不阻塞）
-                node.writeSingleCoil(slaveId, coilNumber, state).catch(err => {
-                    node.log(`Symi按键控制失败: ${err.message}`);
-                });
+                    // 截取完整帧进行解析
+                    const completeFrame = node.serialBuffer.slice(0, frameLen);
+                    
+                    // 移除缓冲区中已处理的部分
+                    node.serialBuffer = node.serialBuffer.slice(frameLen);
+
+                    // 执行解析逻辑
+                    const frame = protocol.parseFrame(completeFrame);
+                    if (!frame) continue;
+
+                    // 只处理SET类型(0x03)的按键事件
+                    if (frame.dataType !== 0x03) continue;
+                    if (frame.deviceType !== 0x01) continue;
+
+                    const deviceAddr = frame.deviceAddr;
+                    const channel = frame.channel;
+                    const state = frame.opInfo[0] === 0x01;
 
-                // 发送应答帧（REPORT类型0x04，反馈LED状态）
-                // 协议规定：面板发送0x03(SET)按键事件，主机应该用0x04(REPORT)反馈LED状态
-                const responseFrame = protocol.buildSingleLightReport(0x01, deviceAddr, channel, state);
-                if (node.client._port && node.client._port.write) {
-                    node.client._port.write(responseFrame);
-                    node.log(`Symi应答已发送(REPORT): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
-                } else if (node.client._client && node.client._client.write) {
-                    // TCP模式
-                    node.client._client.write(responseFrame);
-                    node.log(`Symi应答已发送(REPORT/TCP): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                    const slaveId = 10 + (deviceAddr - 1);
+                    const coilNumber = channel - 1;
+
+                    const slaveConfig = node.config.slaves.find(s => s.address === slaveId);
+                    if (!slaveConfig) continue;
+
+                    if (coilNumber < slaveConfig.coilStart || coilNumber > slaveConfig.coilEnd) continue;
+
+                    node.debug(`Symi按键事件(拼包成功): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                    node.debug(`Symi按键映射: 设备${deviceAddr}通道${channel} → 从站${slaveId}线圈${coilNumber}`);
+
+                    // 写入线圈（异步，不阻塞）
+                    node.writeSingleCoil(slaveId, coilNumber, state).catch(err => {
+                        node.log(`Symi按键控制失败: ${err.message}`);
+                    });
+
+                    // 发送应答帧（REPORT类型0x04，反馈LED状态）
+                    // 协议规定：面板发送0x03(SET)按键事件，主机应该用0x04(REPORT)反馈LED状态
+                    const responseFrame = protocol.buildSingleLightReport(0x01, deviceAddr, channel, state);
+                    if (node.client._port && node.client._port.write) {
+                        node.client._port.write(responseFrame);
+                        node.log(`Symi应答已发送(REPORT): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                    } else if (node.client._client && node.client._client.write) {
+                        // TCP模式
+                        node.client._client.write(responseFrame);
+                        node.log(`Symi应答已发送(REPORT/TCP): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                    }
                 }
 
             } catch (err) {

package/nodes/modbus-slave-switch.js

@@ -399,6 +399,9 @@ module.exports = function(RED) {
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
 
+        // RS-485 拼包缓冲区（解决工控机分包问题）
+        node.rs485Buffer = Buffer.alloc(0);
+
         // Mesh模式状态缓存
         node.meshCurrentStates = null;  // Mesh设备当前状态（用于保持其他路不变）
 
@@ -569,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);
@@ -791,112 +794,229 @@ module.exports = function(RED) {
         };
 
         // 处理RS-485接收到的数据（支持TCP粘包处理）
+        // 处理从串口接收到的RS-485原始数据
         node.handleRs485Data = function(data) {
             try {
-                // 如果是Mesh模式，使用Mesh协议解析
+                // 将新数据拼接到缓冲区
+                node.rs485Buffer = Buffer.concat([node.rs485Buffer, data]);
+
+                // 限制缓冲区大小，防止异常情况下内存溢出（最大1KB）
+                if (node.rs485Buffer.length > 1024) {
+                    node.rs485Buffer = node.rs485Buffer.slice(-1024);
+                }
+
+                // 根据品牌/类型选择不同的拼包解析逻辑
                 if (node.config.buttonType === 'mesh') {
-                    node.handleMeshData(data);
-                    return;
+                    // Mesh 协议拼包逻辑
+                    while (node.rs485Buffer.length >= 5) {
+                        const headerIndex = node.rs485Buffer.indexOf(0x53);
+                        if (headerIndex === -1) {
+                            node.rs485Buffer = Buffer.alloc(0);
+                            break;
+                        }
+                        if (headerIndex > 0) {
+                            node.rs485Buffer = node.rs485Buffer.slice(headerIndex);
+                        }
+                        if (node.rs485Buffer.length < 4) break;
+
+                        const dataLen = node.rs485Buffer[3];
+                        const totalLen = 4 + dataLen + 1; // [53][op][sub][len] + [data...] + [check]
+
+                        if (totalLen > 64 || totalLen < 5) { // 非法长度
+                            node.rs485Buffer = node.rs485Buffer.slice(1);
+                            continue;
+                        }
+
+                        if (node.rs485Buffer.length < totalLen) break; // 数据未到齐
+
+                        const completeFrame = node.rs485Buffer.slice(0, totalLen);
+                        node.rs485Buffer = node.rs485Buffer.slice(totalLen);
+                        
+                        // 验证帧有效性并解析
+                        if (meshProtocol.isMeshFrame(completeFrame)) {
+                            const event = meshProtocol.parseStatusEvent(completeFrame);
+                            if (event) {
+                                node.handleMeshData(event);
+                            }
+                        }
+                    }
+                } else if (node.config.switchBrand === 'clowire') {
+                    // Clowire 协议拼包逻辑 (克伦威尔)
+                    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];
+
+                        for (const frameLen of possibleLengths) {
+                            const startIndex = endIndex - frameLen + 1;
+                            if (startIndex >= 0) {
+                                const completeFrame = node.rs485Buffer.slice(startIndex, endIndex + 1);
+                                if (clowireProtocol.isClowireFrame(completeFrame)) {
+                                    // 找到有效帧，处理它
+                                    node.handleClowireData(completeFrame);
+                                    // 移除到当前帧结束的所有数据
+                                    node.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
+                                    foundFrame = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (foundFrame) continue;
+
+                        // 没找到有效帧，跳过当前的 0xAA，继续寻找下一个
+                        node.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
+                    }
+                } else {
+                    // 亖米 (Symi) 协议拼包逻辑
+                    while (node.rs485Buffer.length >= 15) {
+                        const headerIndex = node.rs485Buffer.indexOf(0x7E);
+                        if (headerIndex === -1) {
+                            node.rs485Buffer = Buffer.alloc(0);
+                            break;
+                        }
+                        if (headerIndex > 0) {
+                            node.rs485Buffer = node.rs485Buffer.slice(headerIndex);
+                        }
+                        if (node.rs485Buffer.length < 4) break;
+
+                        const frameLen = node.rs485Buffer[3];
+                        if (frameLen < 15 || frameLen > 64) {
+                            node.rs485Buffer = node.rs485Buffer.slice(1);
+                            continue;
+                        }
+
+                        if (node.rs485Buffer.length < frameLen) break;
+
+                        const completeFrame = node.rs485Buffer.slice(0, frameLen);
+                        node.rs485Buffer = node.rs485Buffer.slice(frameLen);
+
+                        // 验证帧有效性
+                        if (protocol.isSymiFrame(completeFrame)) {
+                            // 亖米协议：解析所有可能的子帧
+                            const frames = protocol.parseAllFrames(completeFrame);
+                            if (frames && frames.length > 0) {
+                                for (const frame of frames) {
+                                    node.processSymiFrame(frame);
+                                }
+                            }
+                        }
+                    }
                 }
+            } catch (err) {
+                node.log(`解析RS-485数据失败: ${err.message}`);
+            }
+        };
 
-                // 根据品牌选择协议解析
-                if (node.config.switchBrand === 'clowire') {
-                    node.handleClowireData(data);
+        // 提取原 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;
                 }
 
-                // 亖米协议：使用parseAllFrames处理粘包，解析所有帧
-                const frames = protocol.parseAllFrames(data);
-                if (!frames || frames.length === 0) {
-                    return; // 静默忽略无效帧
+                // 检测是否是按键按下事件
+                const buttonEvent = protocol.detectButtonPress(frame);
+                if (!buttonEvent) {
+                    return;
                 }
 
-                // 处理每一个帧
-                for (const frame of frames) {
-                    // 忽略 REPORT (0x04) 类型的帧（这是面板对我们指令的确认，不是按键事件）
-                    // 只处理 SET (0x03) 类型的帧（真正的按键事件）
-                    if (frame.dataType === 0x04) {
-                        continue; // 静默忽略REPORT帧
-                    }
+                // 计算实际按键编号
+                const actualButtonNumber = (buttonEvent.deviceAddr === 1) ? buttonEvent.channel : (buttonEvent.deviceAddr * 4 - 4 + buttonEvent.channel);
+
+                if (buttonEvent.channel === 0x0F && node.config.buttonNumber !== 15) {
+                    return;
+                }
+                
+                if (buttonEvent.raw.localAddr === node.config.switchId && actualButtonNumber === node.config.buttonNumber) {
+                    // 判断按钮类型
+                    const isSceneMode = buttonEvent.isSceneMode ||
+                                       node.config.buttonType === 'scene' ||
+                                       buttonEvent.deviceType === 0x07;
+
+                    // 全局防抖
+                    const debounceKey = `${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}`;
+                    const now = Date.now();
+                    const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
-                    // 检测是否是按键按下事件
-                    const buttonEvent = protocol.detectButtonPress(frame);
-                    if (!buttonEvent) {
-                        continue; // 静默忽略非按键事件
+                    if (now - lastTriggerTime < 200) {
+                        return;
                     }
+                    globalDebounceCache.set(debounceKey, now);
 
-                    // 计算实际按键编号
-                    // 8键面板：deviceAddr=1时，channel直接就是按键编号1-8
-                    // 例如：devAddr=1,channel=7→按键7
-                    // 特殊：channel=0x0F(15)是红外感应触发背光灯
-                    const actualButtonNumber = (buttonEvent.deviceAddr === 1) ? buttonEvent.channel : (buttonEvent.deviceAddr * 4 - 4 + buttonEvent.channel);
-
-                    // 检查是否是我们监听的开关面板和按钮
-                    // switchId对应本地地址（物理面板地址）
-                    // buttonNumber对应实际按键编号（1-8，或15表示背光灯）
-                    // 
-                    // 注意：通道0x0F是红外感应触发背光灯
-                    // 只有当用户配置了buttonNumber=15（按键背光灯）时才处理该帧
-                    // 否则忽略红外感应帧（避免误触发普通按键事件）
-                    if (buttonEvent.channel === 0x0F && node.config.buttonNumber !== 15) {
-                        continue; // 忽略红外感应帧（仅当未配置为背光灯模式时）
+                    // 设置触发源
+                    if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
+                        node.serialPortConfig.setTriggerSource(node.config.switchId);
                     }
-                    
-                    if (buttonEvent.raw.localAddr === node.config.switchId && actualButtonNumber === node.config.buttonNumber) {
-                        // 判断按钮类型：优先使用协议解析结果，其次使用配置
-                        const isSceneMode = buttonEvent.isSceneMode ||
-                                           node.config.buttonType === 'scene' ||
-                                           buttonEvent.deviceType === 0x07;
-
-                        // 全局防抖：防止同一个按键的同一个目标重复触发
-                        // 包含targetSlaveAddress，允许一个按键控制多个不同从站的继电器
-                        const debounceKey = `${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}`;
-                        const now = Date.now();
-                        const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
-                        // 全局防抖：200ms内只触发一次（开关和场景统一防抖时间）
-                        if (now - lastTriggerTime < 200) {
-                            continue; // 静默忽略重复触发
-                        }
-                        globalDebounceCache.set(debounceKey, now);
+                    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'
+                        });
 
-                        // 设置触发源（用于优先队列）
-                        if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
-                            node.serialPortConfig.setTriggerSource(node.config.switchId);
-                        }
+                        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'
+                        });
 
-                        if (isSceneMode) {
-                            node.debug(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber} (opInfo=0x${buttonEvent.opInfo.toString(16).toUpperCase()})`);
-                            // 场景模式：切换状态（每次触发时翻转）
-                            node.currentState = !node.currentState;
-                            node.sendMqttCommand(node.currentState);
-                            
-                            // 场景模式：立即发送LED反馈（修复：不等待状态变化事件）
-                            // 因为currentState已经更新，后续的coilStateChanged事件会被认为"状态未变化"而跳过
-                            node.sendCommandToPanel(node.currentState);
-                        } else {
-                            // 开关模式：根据状态发送ON/OFF
-                            node.debug(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
-                            node.sendMqttCommand(buttonEvent.state);
-                        }
+                        node.sendMqttCommand(buttonEvent.state);
                     }
-                    // 不匹配的节点静默忽略，不输出任何日志
                 }
             } catch (err) {
-                node.log(`解析RS-485数据失败: ${err.message}`);
+                node.log(`处理亖米协议帧失败: ${err.message}`);
             }
         };
 
         // 处理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;
                 }
@@ -968,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);
 
                         // 输出消息
@@ -988,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设备
@@ -1050,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反馈锁和状态缓存
@@ -1095,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.10",
+  "version": "2.9.12",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、多主站独立运行、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步（支持亖米/Clowire品牌），工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {