node-zserial 1.0.22 → 1.0.24

package/package.json

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

package/zserial.js

@@ -24,7 +24,7 @@ module.exports = function (RED) {
                     node.send(msg);
                     done();
                 }, node);
-            } 
+            }
             else if (msg.serialConfigs) {
                 let allLen = msg.serialConfigs.length;
                 let total = msg.serialConfigs.length;
@@ -329,7 +329,7 @@ module.exports = function (RED) {
         node.successMsg = {};
         node.errorMsg = {};
         node._msg = null
-
+        
         function initMsg(msg) {
             node._msg = msg;
             node.totallenth = msg.serialConfigs.length;
@@ -338,7 +338,7 @@ module.exports = function (RED) {
             node.errorMsg = {};
         }
         function zsend(msg, err, alldone, port, done) {
-
+            
             let payload = msg || err;
             node._msg.payload = payload;
             node.totalMsg[port] = payload
@@ -358,7 +358,6 @@ module.exports = function (RED) {
             sendAll(done);
         }
         function onMsg(msg, send, done) {
-
             initMsg(msg);
             if (!msg.serialConfigs) {
                 node.error("需要配置批量配置：msg.serialConfigs");
@@ -370,14 +369,14 @@ module.exports = function (RED) {
             for (var i = 0; i < msg.serialConfigs.length; i++) {
                 var serialConfig = msg.serialConfigs[i];
                 serialConfig._msgid = msg._msgid + "_" + i;
-                getSerialServer(msg, serialConfig, done);
+                getSerialServer( msg, serialConfig, done);
             }
         }
 
         function sendAll(done) {
+            
             try {
                 let len = Object.keys(node.totalMsg).length;
-
                 if (len == node.totallenth) {
                     let payload = {
                         totalMsg: node.totalMsg,
@@ -501,53 +500,82 @@ module.exports = function (RED) {
 
         }
 
+        function isCurNode(msgout, curMsg, _ndoe, sender) {
+            // if (sender == node) { return true; }
+            if (msgout.request_msgid && msgout.request_msgid.startsWith(curMsg._msgid)) {
+                return true
+            }
+            return false
+        }
+
         function setCallback(msg, serialConfig, done) {
             let curPort = serialPool.get(serialConfig);
-            // 确保只绑定一次事件
-            if (curPort._isBindEventInit) {
-                return;
-            }
+            // 确保当前节点只绑定一次事件
+            // if (curPort._isBindEventInit) {
+            //     return;
+            // }
             // node.warn("setCallback called for " + curPort.serial.path);
-            curPort._isBindEventInit = true;
+            // curPort._isBindEventInit = true;
 
-            curPort.on('data', function (msgout, sender) {
+            if (node[`_dataHandler_${curPort.serial.path}`]) {
+                return;
+            }
+            const dataHandler = function (msgout, sender) {
                 if (sender !== node) { return; }
-                msgout.status = "OK";
-                zsend(msgout, null, null, curPort.serial.path, done);
-            });
-            curPort.on('timeout', function (msgout, sender) {
+                try {
+                    msgout.status = "OK";
+                    zsend(msgout, null, null, curPort.serial.path, done);
+                } catch (error) {
+                    node.error(error)
+                }
+
+            }
+
+            const timeoutHandler = function (msgout, sender) {
                 if (sender !== node) { return; }
                 msgout.status = "ERR_TIMEOUT";
                 msgout.port = curPort.serial.path;
                 node.status({ fill: "red", shape: "ring", text: "timeout:::" + curPort.serial.path });
                 zsend(null, msgout, null, curPort.serial.path, done);
-            });
-
-            curPort.on('initerror', function (port, retryNum, olderr) {
-                // zsend(null, {
-                //     status: "ERR_INIT",
-                //     text: `请检查端口是否打开,重试次数${retryNum}`,
-                //     error: olderr,
-                //     port: port
-                // }, null, curPort.serial.path, done);
-            });
-
-
-            curPort.on('retryerror', function (port, retryNum) {
-                // curPort._retryNum = 0;
-                // zsend(null, {
-                //     status: "ERR_retry",
-                //     text: `重试${retryNum}失败`,
-                //     port: port
-                // }, null, curPort.serial.path, done);
-            });
+            }
 
-            curPort.on('closed', function (port) {
-                // node.warn(`串口已关闭:${port}`);
-            });
-            curPort.on('ready', function (port) {
-                // node.warn(`串口已准备好:${port}`);
-            });
+            node[`_dataHandler_${curPort.serial.path}`] = dataHandler
+            node[`_timeoutHandler_${curPort.serial.path}`] = timeoutHandler
+            curPort.on('data', dataHandler);
+            curPort.on('timeout', timeoutHandler);
+
+            node.on('close', function () {
+                node[`_dataHandler_${curPort.serial.path}`] = null
+                node[`_timeoutHandler_${curPort.serial.path}`] = null
+                curPort.off('data', dataHandler);
+                curPort.off('timeout', timeoutHandler);
+            })
+
+            // curPort.on('initerror', function (port, retryNum, olderr) {
+            //     // zsend(null, {
+            //     //     status: "ERR_INIT",
+            //     //     text: `请检查端口是否打开,重试次数${retryNum}`,
+            //     //     error: olderr,
+            //     //     port: port
+            //     // }, null, curPort.serial.path, done);
+            // });
+
+
+            // curPort.on('retryerror', function (port, retryNum) {
+            //     // curPort._retryNum = 0;
+            //     // zsend(null, {
+            //     //     status: "ERR_retry",
+            //     //     text: `重试${retryNum}失败`,
+            //     //     port: port
+            //     // }, null, curPort.serial.path, done);
+            // });
+
+            // curPort.on('closed', function (port) {
+            //     // node.warn(`串口已关闭:${port}`);
+            // });
+            // curPort.on('ready', function (port) {
+            //     // node.warn(`串口已准备好:${port}`);
+            // });
         }
 
         this.on("input", function (msg, send, done) {
@@ -876,6 +904,47 @@ module.exports = function (RED) {
                             return Buffer.from(out);
                         }
 
+
+                        // GNW 蓝牙帧：7E 7E 7E 5A  ...  CS  7E A5
+                        function tryParseBleGNW(input) {
+                            const b = input;
+                            if (b.length < 9) return { ok: false };                   // 最短：4起始 + 1LEN + 1CMD + 0DATA + 1CS + 2结束
+                            // 形态判定：必须以 7E 7E 7E 5A 开头
+                            if (!(b[0] === 0x7E && b[1] === 0x7E && b[2] === 0x7E && b[3] === 0x5A)) {
+                                // 若不是，看看后面是否有候选起点（容错脏字节）
+                                const n = b.indexOf(0x7E);
+                                if (n > 0) return { ok: false, used: n, frame: b.slice(0, n), err: "BLE_NO_7E7E7E5A_AT_START" };
+                                return { ok: false };
+                            }
+
+                            // 向后找结束 A5，要求倒数第二个字节是 0x7E（结束符 7E A5）
+                            let endPos = -1;
+                            for (let i = 5; i < b.length; i++) {
+                                if (b[i] === 0xA5 && b[i - 1] === 0x7E) { endPos = i; break; }
+                            }
+                            if (endPos === -1) return { ok: false };                  // 半包，继续累计
+
+                            const frame = b.slice(0, endPos + 1);                     // [0 .. A5]
+                            // 基本字段位置：len 在 [4]，cmd 在 [5]，CS 在倒数第3个字节
+                            const L = frame[4] >>> 0;
+                            const cs = frame[frame.length - 3] >>> 0;
+
+                            // （宽松）长度一致性：实测总长 T 与 L 的关系为 T = L + 3
+                            const T = frame.length;
+                            if ((T - 3) !== L) {
+                                // 不强制失败，给出“长度不一致”的错误帧提示并丢掉该段，避免卡死
+                                return { ok: false, used: frame.length, frame, err: "BLE_LEN_MISMATCH" };
+                            }
+
+                            // 和校验：从起始 0x7E 到 CS 之前所有字节累加低8位
+                            let sum = 0;
+                            for (let i = 0; i < frame.length - 3; i++) sum = (sum + (frame[i] >>> 0)) & 0xFF;
+                            if (sum !== cs) {
+                                return { ok: false, used: frame.length, frame, err: "BLE_CS_FAIL" };
+                            }
+
+                            return { ok: true, used: frame.length, frame };
+                        }
                         // 645：FE* 68 + 6 addr + 68 + ctrl + len + data + cs + 16
                         function tryParse645(input) {
                             // 统计 FE 前导（仅用于 used，不参与 CS 计算）
@@ -935,42 +1004,47 @@ module.exports = function (RED) {
                             return { ok: false };
                         }
 
-                        // 698（68-LEN 变体）：68 LL LH C ... DATA ... CS 16 ；兼容 FE* 前导
+                        // 698（68-LEN 变体）：68 LL LH C ... DATA ... FCS(2) 16 ；兼容 FE* 前导
                         function tryParse698Len(input) {
-                            // 剥 FE 前导
+                            // 剥离前导 FE
                             const b = stripFE(input);
                             if (b.length < 6 || b[0] !== 0x68) return { ok: false };
-                            // 避免把 645 误判成 698-LEN
+                            // 避免把 645 错误识别为 698-LEN（645 在 b[7] 处固定为 0x68）
                             if (b.length >= 8 && b[7] === 0x68) return { ok: false };
 
-                            // 在缓冲里寻找候选的 0x16 作为帧尾（支持一包多帧/脏数据）
-                            let end = b.indexOf(0x16, 5);
-                            while (end !== -1) {
-                                // —— ① 先试 2 字节 CRC-16/X.25（低字节在前），计算区间：从 LL 开始到 CRC 前一字节 —— 
-                                if (end >= 3) {
-                                    const lo = b[end - 2], hi = b[end - 1];
-                                    const fcs = (hi << 8) | lo;
-                                    const calc = crc16x25(b, /*start=*/1, /*end=*/end - 2); // [LL..CRC-1]
-                                    if (calc === fcs) {
-                                        return { ok: true, used: end + 1, frame: b.slice(0, end + 1) };
-                                    }
-                                }
-
-                                // —— ② 再试 1 字节和校验（sum8），计算区间：从 control 起到 CS 前 —— 
-                                if (end >= 2) {
-                                    const cs = b[end - 1];
-                                    const sum = sum8(b, /*start=*/3, /*end=*/end - 1);
-                                    if (cs === sum) {
-                                        return { ok: true, used: end + 1, frame: b.slice(0, end + 1) };
-                                    }
-                                }
+                            // ---- 严格按长度域 L 判帧 ----
+                            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
+
+                            // 期望 0x16 的位置（相对 b 的起点）：1 + L
+                            const expectedEnd = 1 + L;
+                            // 缓冲区数据还不够，继续累计
+                            if (b.length < expectedEnd + 1) return { ok: false };
+                            // 不是以 0x16 结尾，说明前面有脏字节或起点错位，丢弃 1 字节继续
+                            if (b[expectedEnd] !== 0x16) {
+                                return { ok: false, used: 1, frame: b.slice(0, 1), err: "698_LEN_BAD_END" };
+                            }
 
-                                // 找下一个 0x16
-                                end = b.indexOf(0x16, end + 1);
+                            // FCS 校验（CRC‑16/X.25），计算区间：[LL..FCS 前一字节]
+                            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" };
                             }
 
-                            // 还不能定论，继续累计字节
-                            return { ok: false };
+                            // （可选）HCS 校验：从 LL 开始至 HCS 前一字节
+                            // 按 698.45，HCS 位于地址域之后；为避免复杂度，这里不强制校验 HCS。
+                            // 仅在需要时可补：解析地址域长度后再计算 HCS。
+
+                            return { ok: true, used: expectedEnd + 1, frame: b.slice(0, expectedEnd + 1) };
                         }
 
                         // 698（HDLC）：7E ... [FCS(lo,hi)] 7E，支持 0x7D 转义与 X.25 FCS
@@ -1021,8 +1095,14 @@ module.exports = function (RED) {
 
                             // 抽帧
                             while (assembleBuf.length >= 5) {
-                                // 优先 HDLC，再 645，再 698-Len（避免误判）
-                                let r = tryParse698HDLC(assembleBuf);
+                                // // 优先 HDLC，再 645，再 698-Len（避免误判）
+                                // let r = tryParse698HDLC(assembleBuf);
+                                // if (!r.ok) r = tryParse645(assembleBuf);
+                                // if (!r.ok) r = tryParse698Len(assembleBuf);
+
+                                // --fix-20251108-先 BLE（7E7E7E5A…7EA5），再 698-HDLC，再 645，再 698-LEN
+                                let r = tryParseBleGNW(assembleBuf);
+                                if (!r.ok) r = tryParse698HDLC(assembleBuf);
                                 if (!r.ok) r = tryParse645(assembleBuf);
                                 if (!r.ok) r = tryParse698Len(assembleBuf);