node-zserial 1.0.26 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-zserial",
-    "version": "1.0.26",
+    "version": "1.0.28",
     "description": "Node-RED nodes to talk to serial ports",
     "dependencies": {
         "serialport": "^12.0.0"

package/zserial.js

@@ -956,17 +956,42 @@ module.exports = function (RED) {
                             const endIdx = total - 1;                  // 末尾 0x16 索引
                             const csIdx = total - 2;                  // ★ CS 在倒数第2个字节
 
-                            // CS = 从第一个 0x68 起累加到 CS 之前（不含 CS）
+                            // CS 双模校验：
+                            //  - full：从第一个 0x68 起累加到 CS 前（不含 CS）
+                            //  - std ：从第二个 0x68 后（C+L+DATA）累加到 CS 前
                             const csOK = (end) => {
-                                const e = end;              // e == total
-                                const cs = b[e - 2];         // csIdx
-                                const s = sum8(b, 0, e - 2);
-                                return cs === s;
+                                const e = end;               // e == total
+                                const cs = b[e - 2];         // CS 在倒数第2字节
+
+                                // full 模式
+                                const sFull = sum8(b, 0, e - 2);
+                                if (cs === sFull) return { ok: true, mode: 'full', calc: sFull };
+
+                                // std 模式（需确保第二个 0x68 存在于固定位置7）
+                                if (b.length >= 10 && b[7] === 0x68) {
+                                    // 第二个 0x68 后开始：CTRL(8) + LEN(9) + DATA...
+                                    const sStd = sum8(b, 8, e - 2);
+                                    if (cs === sStd) return { ok: true, mode: 'std', calc: sStd };
+                                    return { ok: false, mode: 'std', calc: sStd, calc_full: sFull };
+                                }
+                                return { ok: false, mode: 'full', calc: sFull };
                             };
 
                             // 1) 优先按 LEN 快速命中
-                            if (b.length >= total && b[endIdx] === 0x16 && csOK(total)) {
-                                return { ok: true, used: feCount + total, frame: input.slice(0, feCount + total) };
+                            if (b.length >= total && b[endIdx] === 0x16) {
+                                const ck = csOK(total);
+                                if (ck && ck.ok) {
+                                    const frame = input.slice(0, feCount + total);
+                                    // 透出校验模式，便于排障：部分设备使用 std 模式
+                                    try {
+                                        frame._meta = Object.assign({}, frame._meta || {}, {
+                                            proto: '645',
+                                            cs_mode: ck.mode,
+                                            cs_calc: ck.calc
+                                        });
+                                    } catch (e) { }
+                                    return { ok: true, used: feCount + total, frame };
+                                }
                             }
 
                             // 2) 回溯：向后找 0x16 做候选结尾，再校验 CS（兼容异常 LEN/粘包）
@@ -974,10 +999,17 @@ module.exports = function (RED) {
                                 if (b[end - 1] !== 0x16) continue;
                                 // 候选帧至少要有 …… + CS + 16，因此 end >= 13 且 csIdx=end-2 >= 0
                                 if (end >= 13) {
-                                    const cs = b[end - 2];
-                                    const s = sum8(b, 0, end - 2);
-                                    if (cs === s) {
-                                        return { ok: true, used: feCount + end, frame: input.slice(0, feCount + end) };
+                                    const ck = csOK(end);
+                                    if (ck && ck.ok) {
+                                        const frame = input.slice(0, feCount + end);
+                                        try {
+                                            frame._meta = Object.assign({}, frame._meta || {}, {
+                                                proto: '645',
+                                                cs_mode: ck.mode,
+                                                cs_calc: ck.calc
+                                            });
+                                        } catch (e) { }
+                                        return { ok: true, used: feCount + end, frame };
                                     }
                                 }
                             }
@@ -991,45 +1023,96 @@ module.exports = function (RED) {
 
                         // 698（68-LEN 变体）：68 LL LH C ... DATA ... FCS(2) 16 ；兼容 FE* 前导
                         function tryParse698Len(input) {
-                            // 剥离前导 FE
+                            // 剥离前导 FE（注意：这里只做 698-LEN 侧的兼容；645 另有自己的 FE 处理）
                             const b = stripFE(input);
                             if (b.length < 6 || b[0] !== 0x68) return { ok: false };
-                            // 避免把 645 错误识别为 698-LEN（645 在 b[7] 处固定为 0x68）
-                            if (b.length >= 8 && b[7] === 0x68) return { ok: false };
 
-                            // ---- 严格按长度域 L 判帧 ----
+                            // ---- 读取长度域 ----
+                            // 68 [LL] [LH] [C] ... [FCS(lo)] [FCS(hi)] 16
                             const LL = b[1] >>> 0;
                             const LH = b[2] >>> 0;
-                            let Lraw = (LH << 8) | LL; // 含单位位、保留位
-                            const isKB = (Lraw & 0x4000) !== 0;      // bit14：单位位（0=字节，1=KB）
-                            Lraw &= 0x3FFF;                          // 清除单位位与保留位，仅保留长度值
 
-                            // 仅支持常见“字节”为单位的场景；若为 KB 单位，展开至字节
-                            let L = isKB ? (Lraw << 10) : Lraw;      // KB -> *1024
+                            // Lraw 含单位位/保留位：bit14 为单位位（0=字节，1=KB）
+                            let Lraw = (LH << 8) | LL;
+                            const isKB = (Lraw & 0x4000) !== 0;
+                            Lraw &= 0x3FFF; // 清掉单位位/保留位，只留下数值
+
+                            // 绝大多数场景长度单位为“字节”；若遇到 KB 单位则折算
+                            const L = isKB ? (Lraw << 10) : Lraw; // KB -> *1024
+
+                            // ------------------------ 关键防误判（核心修复点） ------------------------
+                            // 误判根因：645 帧形态为 68 + 6字节地址 + 68 ...，地址字节中“偶然出现 0x16”
+                            // 例如：68 02 80 16 00 00 00 68 ...
+                            // 若把 LL=0x02、LH=0x80 解读为 698-LEN 长度，则 L=2，expectedEnd=3，b[3]=0x16
+                            // 从而被 698-LEN 误判为 “68 02 80 16” 一帧，导致吞掉 645 的帧头并产生残片。
+
+                            // 约束 1：698-LEN 的 L 不可能极短（至少应包含：C + 头字段 + FCS(2)）
+                            // 这里给经验下限 6（偏保守，既能挡住 L=2，又尽量不误伤极端设备）
+                            // 若现场仍有碰撞，可把下限提高到 8 或 10（建议先保留 6）。
+                            const MIN_698_LEN_L = 6;
+                            if (L < MIN_698_LEN_L) {
+                                // 不消费任何字节，让后续 parser（如 645）继续尝试
+                                return { ok: false };
+                            }
+
+                            // 约束 2：控制域 C 在 b[3]，不可能是 0x16（结束符）
+                            // 若 b[3] == 0x16，几乎必然是 645 地址域碰撞导致的误判
+                            if (b.length >= 4 && b[3] === 0x16) {
+                                return { ok: false };
+                            }
+                            // ------------------------------------------------------------------------
 
-                            // 期望 0x16 的位置（相对 b 的起点）：1 + L
+                            // 期望 0x16 的位置（相对 b 起点）：1 + L
+                            // 解释：L 表示从 LL 开始到 FCS(含) 之前的长度？各厂实现略有差异
+                            // 你现有逻辑采用 expectedEnd = 1 + L，并要求 b[expectedEnd] == 0x16
                             const expectedEnd = 1 + L;
-                            // 缓冲区数据还不够，继续累计
+
+                            // 半包：继续累积
                             if (b.length < expectedEnd + 1) return { ok: false };
-                            // 不是以 0x16 结尾，说明前面有脏字节或起点错位，丢弃 1 字节继续
+
+                            // 若 expectedEnd 位置不是 0x16，说明起点错位或存在脏字节
+                            // 这里消费 1 字节，避免死循环卡住
                             if (b[expectedEnd] !== 0x16) {
                                 return { ok: false, used: 1, frame: b.slice(0, 1), err: "698_LEN_BAD_END" };
                             }
 
-                            // FCS 校验（CRC‑16/X.25），计算区间：[LL..FCS 前一字节]
+                            // ------------------------ FCS 校验（CRC-16/X.25） ------------------------
+                            // FCS 位于 0x16 前两字节，低字节在前（lo, hi）
+                            if (expectedEnd - 2 < 0) return { ok: false };
+
                             const fcsLo = b[expectedEnd - 2];
                             const fcsHi = b[expectedEnd - 1];
                             const fcs = (fcsHi << 8) | fcsLo;
-                            const calc = crc16x25(b, 1, expectedEnd - 2);
-                            if (calc !== fcs) {
-                                return { ok: false, used: 1, frame: b.slice(0, 1), err: "698_LEN_FCS_FAIL" };
-                            }
 
-                            // （可选）HCS 校验：从 LL 开始至 HCS 前一字节
-                            // 按 698.45，HCS 位于地址域之后；为避免复杂度，这里不强制校验 HCS。
-                            // 仅在需要时可补：解析地址域长度后再计算 HCS。
+                            // 不同实现对“CRC 覆盖范围”存在差异，常见两种：
+                            // A) 从 0x68 开始算到 FCS 前（不含 FCS 与 0x16）
+                            // B) 从 LL 开始算到 FCS 前（不含 FCS 与 0x16）
+                            const calcA = crc16x25(b, 0, expectedEnd - 2);
+                            const calcB = crc16x25(b, 1, expectedEnd - 2);
+                            const fcsOK = (calcA === fcs) || (calcB === fcs);
+
+                            // 注意：FCS 不通过时不能返回 ok:true（否则会“强制截帧”吞掉其它协议帧）
+                            // 但为了防止卡死，这里仍消费掉该段，并作为错误帧上报给 emitErr。
+                            if (!fcsOK) {
+                                return {
+                                    ok: false,
+                                    used: expectedEnd + 1,
+                                    frame: b.slice(0, expectedEnd + 1),
+                                    fcs_ok: false,
+                                    fcs_frame: fcs,
+                                    fcs_calc_a: calcA,
+                                    fcs_calc_b: calcB,
+                                    err: "698_LEN_FCS_FAIL"
+                                };
+                            }
 
-                            return { ok: true, used: expectedEnd + 1, frame: b.slice(0, expectedEnd + 1) };
+                            // FCS 通过：返回完整帧（含 0x68..0x16）
+                            return {
+                                ok: true,
+                                used: expectedEnd + 1,
+                                frame: b.slice(0, expectedEnd + 1),
+                                fcs_ok: true
+                            };
                         }
 
                         // 698（HDLC）：7E ... [FCS(lo,hi)] 7E，支持 0x7D 转义与 X.25 FCS
@@ -1085,19 +1168,61 @@ module.exports = function (RED) {
                                 // if (!r.ok) r = tryParse645(assembleBuf);
                                 // if (!r.ok) r = tryParse698Len(assembleBuf);
 
-                                // --fix-20251108-先 BLE（7E7E7E5A…7EA5），再 698-HDLC，再 645，再 698-LEN
+                                // --fix-20251213-先 BLE（7E7E7E5A…7EA5），再 698-HDLC，再 698-LEN，再 645
+                                // 关键：698-LEN 必须优先于 645，否则遇到 698 帧内出现 0x68（如示例报文第7字节）会被 645 误判并卡住
                                 let r = tryParseBleGNW(assembleBuf);
                                 if (!r.ok) r = tryParse698HDLC(assembleBuf);
-                                if (!r.ok) r = tryParse645(assembleBuf);
                                 if (!r.ok) r = tryParse698Len(assembleBuf);
+                                if (!r.ok) r = tryParse645(assembleBuf);
 
                                 if (r.ok) {
+                                    // 附加解析元数据（例如 698 FCS 校验结果），供上层排障
+                                    if (r && typeof r === 'object') {
+                                        try {
+                                            r.frame._meta = {
+                                                proto: r.proto || undefined,
+                                                fcs_ok: (typeof r.fcs_ok === 'boolean') ? r.fcs_ok : undefined,
+                                                err: r.err || undefined,
+                                                fcs_frame: r.fcs_frame,
+                                                fcs_calc_a: r.fcs_calc_a,
+                                                fcs_calc_b: r.fcs_calc_b
+                                            };
+                                        } catch (e) {
+                                            // ignore
+                                        }
+                                    }
                                     emitOk(r.frame);
                                     assembleBuf = assembleBuf.slice(r.used);
                                     continue;
                                 }
                                 if (r.used) {
-                                    emitErr(r.frame, r.err || "FRAME_INVALID");
+                                    // 如果 parser 返回了“可消费”的错误帧（例如 698-LEN FCS_FAIL），
+                                    // 这里把诊断信息写入 frame._meta，供上层日志/排障使用。
+                                    if (r && typeof r === 'object') {
+                                        try {
+                                            if (r.frame) {
+                                                // 统一把元数据挂到 frame 上，避免引用未定义变量导致运行期异常
+                                                r.frame._meta = Object.assign({}, r.frame._meta || {}, {
+                                                    // proto：用于上层区分到底是 645 / 698-hdlc / 698-len / ble 等
+                                                    proto: (r.fcs_ok === false) ? '698-len' : (r.proto || undefined),
+                                                    // FCS 校验信息（仅当 698-LEN 校验失败时有意义）
+                                                    fcs_ok: (typeof r.fcs_ok === 'boolean') ? r.fcs_ok : undefined,
+                                                    fcs_frame: r.fcs_frame,
+                                                    fcs_calc_a: r.fcs_calc_a,
+                                                    fcs_calc_b: r.fcs_calc_b,
+                                                    // err：更精确的错误原因
+                                                    err: r.err || "FRAME_INVALID"
+                                                });
+                                            }
+                                        } catch (e) {
+                                            // ignore：不要因为诊断信息影响主流程
+                                        }
+                                    }
+
+                                    // 错误帧统一走 emitErr，reason 以 r.err 为准
+                                    emitErr(r.frame, (r && r.err) ? r.err : "FRAME_INVALID");
+
+                                    // 消费掉该段，防止 assembleBuf 卡死
                                     assembleBuf = assembleBuf.slice(r.used);
                                     continue;
                                 }
@@ -1138,6 +1263,14 @@ module.exports = function (RED) {
                                         msgout.payload = m;
                                         msgout.port = port;
                                         msgout.status = "OK";
+
+                                        // 若解析器附带了元数据（例如 698 FCS 校验结果），一并输出
+                                        if (frameBuf && frameBuf._meta) {
+                                            msgout.frame_meta = frameBuf._meta;
+                                            // 便于后续 GC：避免 assembleBuf 长期引用
+                                            try { delete frameBuf._meta; } catch (e) { }
+                                        }
+
                                         obj._emitter.emit('data', msgout, last_sender);
                                     },
                                     // 错误帧（已有边界但校验/结束符不通过）