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

package/README.md

@@ -952,10 +952,18 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.9.10 (2026-01-08)
+**当前版本**: v2.9.11 (2026-01-09)
+
+**v2.9.11 更新内容**：
+- **串口数据拼包优化 (解决工控机分包问题)**：
+  - 在 `modbus-master` 和 `modbus-slave-switch` 节点中引入了协议级拼包缓冲区 `serialBuffer` / `rs485Buffer`。
+  - 针对工业机硬件 UART FIFO 触发阈值（如 8 字节）导致的数据断裂，实现了自动拼包解析。
+  - 逻辑支持：自动寻找帧头、动态识别长度字段、跨包拼接、CRC/校验和验证。
+  - 兼容协议：亖米 (Symi) 私有协议、Clowire (克伦威尔) 485 协议、Mesh 协议。
+  - 确保在任何硬件环境下（尤其是工控机）都能 100% 稳定识别从站开关、传感器等 485 设备。
 
 **v2.9.10 更新内容**：
-- **日志系统优化（解决日志占用问题）**：
+- **日志系统优化 (解决日志占用问题)**：
   - **彻底静默重连日志**：将 TCP/串口连接过程中的 `node.error` 降级为 `node.log` 或 `node.debug`，不再发送到 Node-RED 调试面板（Debug Tab），彻底解决重连期间日志刷屏问题。
   - **智能过滤**：相同的连接错误在重试期间不再重复输出日志（每 10 分钟仅后台提醒一次）。
   - **状态栏增强**：将具体错误信息（如“拒绝连接”、“串口不存在”）直接显示在节点状态文字中，无需查看日志即可掌握连接状况。

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设备当前状态（用于保持其他路不变）
 
@@ -791,102 +794,185 @@ module.exports = function(RED) {
         };
 
         // 处理RS-485接收到的数据（支持TCP粘包处理）
+        // 处理从串口接收到的RS-485原始数据
         node.handleRs485Data = function(data) {
             try {
-                // 如果是Mesh模式，使用Mesh协议解析
-                if (node.config.buttonType === 'mesh') {
-                    node.handleMeshData(data);
-                    return;
-                }
+                // 将新数据拼接到缓冲区
+                node.rs485Buffer = Buffer.concat([node.rs485Buffer, data]);
 
-                // 根据品牌选择协议解析
-                if (node.config.switchBrand === 'clowire') {
-                    node.handleClowireData(data);
-                    return;
+                // 限制缓冲区大小，防止异常情况下内存溢出（最大1KB）
+                if (node.rs485Buffer.length > 1024) {
+                    node.rs485Buffer = node.rs485Buffer.slice(-1024);
                 }
 
-                // 亖米协议：使用parseAllFrames处理粘包，解析所有帧
-                const frames = protocol.parseAllFrames(data);
-                if (!frames || frames.length === 0) {
-                    return; // 静默忽略无效帧
-                }
+                // 根据品牌/类型选择不同的拼包解析逻辑
+                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) {
+                            node.rs485Buffer = Buffer.alloc(0);
+                            break;
+                        }
+                        if (headerIndex > 0) {
+                            node.rs485Buffer = node.rs485Buffer.slice(headerIndex);
+                        }
+                        if (node.rs485Buffer.length < 4) break;
 
-                // 处理每一个帧
-                for (const frame of frames) {
-                    // 忽略 REPORT (0x04) 类型的帧（这是面板对我们指令的确认，不是按键事件）
-                    // 只处理 SET (0x03) 类型的帧（真正的按键事件）
-                    if (frame.dataType === 0x04) {
-                        continue; // 静默忽略REPORT帧
-                    }
+                        const dataLen = node.rs485Buffer[3];
+                        const totalLen = 4 + dataLen + 1; // [53][op][sub][len] + [data...] + [check]
+
+                        if (totalLen > 64) { // 非法长度
+                            node.rs485Buffer = node.rs485Buffer.slice(1);
+                            continue;
+                        }
+
+                        if (node.rs485Buffer.length < totalLen) break; // 数据未到齐
 
-                    // 检测是否是按键按下事件
-                    const buttonEvent = protocol.detectButtonPress(frame);
-                    if (!buttonEvent) {
-                        continue; // 静默忽略非按键事件
+                        const completeFrame = node.rs485Buffer.slice(0, totalLen);
+                        node.rs485Buffer = node.rs485Buffer.slice(totalLen);
+                        
+                        // 处理解析出来的完整Mesh帧
+                        node.handleMeshData(completeFrame);
                     }
+                } else if (node.config.switchBrand === 'clowire') {
+                    // Clowire 协议拼包逻辑 (克伦威尔)
+                    // 特点：以 0xAA 结尾，长度通常为 9 或 11 字节
+                    while (node.rs485Buffer.length >= 9) {
+                        const endIndex = node.rs485Buffer.indexOf(0xAA);
+                        if (endIndex === -1) {
+                            // 如果缓冲区太长且没找到结尾，保留一部分可能的数据
+                            if (node.rs485Buffer.length > 32) {
+                                node.rs485Buffer = node.rs485Buffer.slice(-16);
+                            }
+                            break;
+                        }
 
-                    // 计算实际按键编号
-                    // 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; // 忽略红外感应帧（仅当未配置为背光灯模式时）
+                        // 尝试匹配可能的长度
+                        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.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
+                                    node.handleClowireData(completeFrame);
+                                    foundFrame = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (foundFrame) continue;
+
+                        // 没找到有效帧，跳过当前的 0xAA
+                        node.rs485Buffer = node.rs485Buffer.slice(endIndex + 1);
                     }
-                    
-                    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;
+                } else {
+                    // 亖米 (Symi) 协议拼包逻辑
+                    // 格式: 7E [addr] [type] [len] ... [tail:7D]
+                    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;
 
-                        // 全局防抖：200ms内只触发一次（开关和场景统一防抖时间）
-                        if (now - lastTriggerTime < 200) {
-                            continue; // 静默忽略重复触发
+                        const frameLen = node.rs485Buffer[3];
+                        if (frameLen < 15 || frameLen > 64) {
+                            node.rs485Buffer = node.rs485Buffer.slice(1);
+                            continue;
                         }
-                        globalDebounceCache.set(debounceKey, now);
 
-                        // 设置触发源（用于优先队列）
-                        if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
-                            node.serialPortConfig.setTriggerSource(node.config.switchId);
+                        if (node.rs485Buffer.length < frameLen) break;
+
+                        const completeFrame = node.rs485Buffer.slice(0, frameLen);
+                        node.rs485Buffer = node.rs485Buffer.slice(frameLen);
+
+                        // 验证尾部
+                        if (completeFrame[completeFrame.length - 1] !== 0x7D) {
+                            // 尾部不匹配，说明不是有效帧
+                            continue;
                         }
 
-                        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);
+                        // 亖米协议：使用parseAllFrames处理粘包，解析所有帧
+                        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}`);
             }
         };
 
+        // 提取原 handleRs485Data 中的亖米协议处理逻辑
+        node.processSymiFrame = function(frame) {
+            try {
+                // 忽略 REPORT (0x04) 类型的帧
+                if (frame.dataType === 0x04) {
+                    return;
+                }
+
+                // 检测是否是按键按下事件
+                const buttonEvent = protocol.detectButtonPress(frame);
+                if (!buttonEvent) {
+                    return;
+                }
+
+                // 计算实际按键编号
+                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;
+
+                    if (now - lastTriggerTime < 200) {
+                        return;
+                    }
+                    globalDebounceCache.set(debounceKey, now);
+
+                    // 设置触发源
+                    if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
+                        node.serialPortConfig.setTriggerSource(node.config.switchId);
+                    }
+
+                    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);
+                        node.sendCommandToPanel(node.currentState);
+                    } else {
+                        node.debug(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
+                        node.sendMqttCommand(buttonEvent.state);
+                    }
+                }
+            } catch (err) {
+                node.log(`处理亖米协议帧失败: ${err.message}`);
+            }
+        };
+
         // 处理Clowire协议数据
         node.handleClowireData = function(data) {
             try {

package/package.json

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