node-red-zelecproto 0.1.1 → 0.1.3

package/645.js

@@ -433,6 +433,20 @@ function decode645(_msg) {
         return arr.includes(di)
     }
 
+    function expandBits16(v) {
+        const bits = {};
+        for (let i = 0; i < 16; i++) {
+            bits[`bit${i}`] = (v >> i) & 0x1;
+        }
+        return bits;
+    }
+    function expandBits32(v) {
+        const bits = {};
+        for (let i = 0; i < 32; i++) {
+            bits[`bit${i}`] = (v >>> i) & 0x1;
+        }
+        return bits;
+    }
 
     // —— 常用分支（保留你的原分支，增加越界保护）——
     function buildDays(prefix) {
@@ -520,31 +534,22 @@ function decode645(_msg) {
                 rawValue: w1,
                 rawBlockHex: statusBlockHex,
                 binary: bin16(w1),
-                keys: {
-                    '停电抄表电池欠压': !!bit(w1, 3),
-                    '时钟电池欠压': !!bit(w1, 2),
-                    '有功功率方向反向': !!bit(w1, 4),
-                    '无功功率方向反向': !!bit(w1, 5),
-                    '控制回路错误': !!bit(w1, 8),
-                    'ESAM错误': !!bit(w1, 9),
-                    '内部程序错误': !!bit(w1, 12),
-                    '存储器故障或损坏': !!bit(w1, 13),
-                    '透支状态': !!bit(w1, 14),
-                    '时钟故障': !!bit(w1, 15)
-                }
+                bits: expandBits16(w1)
             };
 
             // 状态字2/3只保留原始数值和binary，具体位义由上层业务或文档表解释。
             const w2 = readU16LE();
             const word2 = (w2 === null) ? null : {
                 rawValue: w2,
-                binary: bin16(w2)
+                binary: bin16(w2),
+                bits: expandBits16(w2)
             };
 
             const w3 = readU16LE();
             const word3 = (w3 === null) ? null : {
                 rawValue: w3,
-                binary: bin16(w3)
+                binary: bin16(w3),
+                bits: expandBits16(w3)
             };
 
             // —— 密钥状态字（与你现有的 04000508 保持一致，32位）——
@@ -553,6 +558,7 @@ function decode645(_msg) {
                 rawValue: w8,
                 hexValue: w8.toString(16).toUpperCase().padStart(8, '0'),
                 binary: bin32(w8),
+                bits: expandBits32(w8),
                 keys: {
                     '主控密钥有效': !!bit(w8, 0),
                     '身份认证密钥有效': !!bit(w8, 1),
@@ -581,18 +587,7 @@ function decode645(_msg) {
 
             value = {
                 rawValue: v, binary: bin,
-                keys: {
-                    '停电抄表电池欠压': !!(v & (1 << 3)),    // bit3: 0=正常, 1=欠压
-                    '时钟电池欠压': !!(v & (1 << 2)),        // bit2: 0=正常, 1=欠压
-                    '有功功率方向反向': !!(v & (1 << 4)),    // bit4: 0=正向, 1=反向
-                    '无功功率方向反向': !!(v & (1 << 5)),    // bit5: 0=正向, 1=反向
-                    '控制回路错误': !!(v & (1 << 8)),        // bit8: 0=正常, 1=错误
-                    'ESAM错误': !!(v & (1 << 9)),           // bit9: 0=正常, 1=错误
-                    '内部程序错误': !!(v & (1 << 12)),       // bit12: 0=正常, 1=错误
-                    '存储器故障或损坏': !!(v & (1 << 13)),   // bit13: 0=正常, 1=故障
-                    '透支状态': !!(v & (1 << 14)),          // bit14: 0=正常, 1=透支
-                    '时钟故障': !!(v & (1 << 15))           // bit15: 0=正常, 1=故障
-                }
+                bits: expandBits16(v)
             };
         } else if (di === '04000502' && arrPush.length >= 6) {
             // 状态字2只返回原始数值，binary为bit15..bit0。
@@ -603,7 +598,8 @@ function decode645(_msg) {
 
             value = {
                 rawValue: v,
-                binary: bin
+                binary: bin,
+                bits: expandBits16(v)
             };
         } else if (di === '04000503' && arrPush.length >= 6) {
             // 状态字3只返回原始数值，binary为bit15..bit0。
@@ -614,7 +610,8 @@ function decode645(_msg) {
 
             value = {
                 rawValue: v,
-                binary: bin
+                binary: bin,
+                bits: expandBits16(v)
             };
         }
         // else if (['0000FF00', '0001FF00', '0002FF00'].includes(di) && arrPush.length > 4) {
@@ -629,6 +626,7 @@ function decode645(_msg) {
                 rawValue: v,
                 hexValue: v.toString(16).toUpperCase().padStart(8, '0'),
                 binary: v.toString(2).padStart(32, '0'),
+                bits: expandBits32(v),
                 keys: {
                     '主控密钥有效': !!(v & (1 << 0)), '身份认证密钥有效': !!(v & (1 << 1)), '密钥协商密钥有效': !!(v & (1 << 2)),
                     '密钥更新密钥有效': !!(v & (1 << 3)), '传输密钥有效': !!(v & (1 << 4)), '保护密钥有效': !!(v & (1 << 5)),
@@ -757,6 +755,9 @@ function decode645(_msg) {
                 unit: 'V',
                 description: `${di === '02800008' ? '时钟电池电压' : '停电抄表电池电压'}: ${v.toFixed(2)}V`
             };
+        } else if (di === '0280000A' && arrPush.length >= 8) {
+            // 0280000A: 内部电池工作时间，4字节，单位分
+            value = bytesToIntBE(arrPush.slice(-4).reverse());
         } else if (di === '0400040A' && arrPush.length >= 7) {
             // 无功脉冲常数：DI(4) + N3(3字节BCD，小端)
             const dataBytes = arrPush.slice(4, 7); // LE：低字节在前
@@ -770,13 +771,7 @@ function decode645(_msg) {
         } else if (di === '03300D01' && arrPush.length >= 16) {
             value = parseCoverOpenLast645(arrPush);
         } else {
-            // 未匹配的DI，返回去偏移(−0x33)后的原始数据，便于排查/厂商私有解析
-            value = {
-                rawMinus33: bytesToHex(arrPush).replace(/\s+/g, ''),           // 含DI(4B) + 数据
-                di,
-                data: bytesToHex(arrPush.slice(4)).replace(/\s+/g, ''),        // 纯数据部分（不含DI）
-                note: '未识别DI，已返回去0x33的原始数据'
-            };
+            value = parseGeneric645Data(di, arrPush);
         }
     } catch (e) {
         return Object.assign(result, { ok: false, reason: 'decode_exception', exec_addr, di, ctrl, len, raw: put, err: String(e) });
@@ -890,6 +885,44 @@ function bcdDigitsStrLE(bytes) {
     return s;
 }
 
+function parseGeneric645Data(di, arrPush) {
+    const dataBytes = Array.from(arrPush.slice(4));
+    const dataHex = bytesToHex(dataBytes).replace(/\s+/g, '');
+    const result = {
+        rawMinus33: bytesToHex(arrPush).replace(/\s+/g, ''),
+        di,
+        data: dataHex,
+        length: dataBytes.length,
+        note: '未识别DI，已按通用格式解析候选值'
+    };
+
+    if (dataBytes.length === 0) return result;
+
+    result.uintLE = bytesToUInt(dataBytes, true);
+    result.uintBE = bytesToUInt(dataBytes, false);
+
+    try {
+        result.bcdLE = bcdLEToInt(dataBytes);
+        result.bcdText = bcdDigitsStrLE(dataBytes);
+    } catch (_) {
+        result.bcdLE = null;
+    }
+
+    if (dataBytes.every(b => b >= 0x20 && b <= 0x7E)) {
+        result.ascii = Buffer.from(dataBytes).toString('ascii');
+    }
+
+    return result;
+}
+
+function bytesToUInt(bytes, littleEndian) {
+    if (!bytes || bytes.length === 0) return null;
+    const arr = littleEndian ? bytes.slice().reverse() : bytes;
+    const hex = Buffer.from(arr).toString('hex') || '0';
+    const value = BigInt(`0x${hex}`);
+    return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
+}
+
 
 // === 开盖明细专用工具 ===
 

package/698.js

@@ -140,6 +140,7 @@ const OAD_CATEGORIES = {
     BATTERY_VOLTAGE: {
         "CLOCK_BATTERY_VOLTAGE": { oad: "20110200", desc: "时钟电池电压", type: "double-long-unsigned", unit: "V", scale: -2 },
         "POWER_DOWN_READING_BATTERY_VOLTAGE": { oad: "20120200", desc: "停电抄表电池电压", type: "double-long-unsigned", unit: "V", scale: -2 },
+        "CLOCK_BATTERY_WORK_TIME": { oad: "20130200", desc: "时钟电池工作时间", type: "double-long-unsigned", unit: "min", scale: 0 },
     },
     FREEZE_DATA: {
         "DAILY_FREEZE": { oad: "50040200", desc: "日冻结", requestType: "record" },
@@ -870,15 +871,11 @@ function parseStatusWordFromAxdrBitString(buffer) {
     const bytes = buffer.slice(start, end);
     if (bytes.length < 2) return null;
     const bits = [];
-    const lowToHighBits = [];
-    // A-XDR bit-string按每字节高位到低位展开；另保留低位到高位展示用于和现场口径对照。
+    // A-XDR bit-string按每字节高位到低位展开。
     for (const byte of bytes.slice(0, 2)) {
         for (let bit = 7; bit >= 0; bit--) {
             bits.push((byte >> bit) & 0x01);
         }
-        for (let bit = 0; bit <= 7; bit++) {
-            lowToHighBits.push((byte >> bit) & 0x01);
-        }
     }
     let statusWord = 0;
     // 文档表F.x中的bit编号按展开后的bit-string下标映射，后续binary再按645一致的数值形式输出。
@@ -887,136 +884,129 @@ function parseStatusWordFromAxdrBitString(buffer) {
     }
     return {
         statusWord,
-        binaryLowToHigh: lowToHighBits.slice(0, 16).join(''),
-        binaryHighToLow: bits.slice(0, 16).join('')
+        binary: bits.slice(0, 16).join(''),
+        consumed: end
     };
 }
 
-/**
- * 解析电表运行状态字2 - 与645协议格式保持一致
- * @param {Buffer} dataBuffer - 数据缓冲区
- * @returns {Object} 解析结果
- */
-
-function parseMeterStatus(dataBuffer, oad = '20140201') {
-    const result = createStandardResult("电表状态", oad, dataBuffer);
-    try {
-        // 1. 读取原始状态字（小端）
-        const statusWordLe = parseMeterStatusOptimized(dataBuffer);
-
-        // 2. 转换为大端，用于大端逻辑判断
-        const statusWordBe = toBigEndian16(statusWordLe);
-
-        if (statusWordBe !== null) {
-            const valTmp = statusWordBe & 0xFFFF;
-            const bin = valTmp.toString(2).padStart(16, '0'); // 最高位bit15在最左
+function expandBits16(v) {
+    const bits = {};
+    for (let i = 0; i < 16; i++) {
+        bits[`bit${i}`] = (v >> i) & 0x1;
+    }
+    return bits;
+}
 
-            // 3. 大端判断：bit0 是最左边的最高位
-            result.value = {
-                rawValue: valTmp,
-                binary: bin,
-                keys: {
-                    'bit15 时钟故障': bin[0] === '1',
-                    'bit14 透支状态': bin[1] === '1',
-                    'bit13 存储器故障或损坏': bin[2] === '1',
-                    'bit12 内部程序错误': bin[3] === '1',
-                    'bit11 保留': bin[4] === '1',
-                    'bit10 保留': bin[5] === '1',
-                    'bit9  ESAM错误': bin[6] === '1',
-                    'bit8  控制回路错误': bin[7] === '1',
-                    'bit7  保留': bin[8] === '1',
-                    'bit6  保留': bin[9] === '1',
-                    'bit5  无功功率方向反向': bin[10] === '1',
-                    'bit4  有功功率方向反向': bin[11] === '1',
-                    'bit3  停电抄表电池欠压': bin[12] === '1',
-                    'bit2  时钟电池欠压': bin[13] === '1',
-                    'bit1  需量积算方式': bin[14] === '1',
-                    'bit0  保留': bin[15] === '1'
-                }
-            };
+function format698StatusWord(statusWord, bitStringStatus = null, index = null) {
+    const val16 = statusWord & 0xFFFF;
+    return {
+        ...(index == null ? {} : { index }),
+        rawValue: val16,
+        statusWordHex: val16.toString(16).padStart(4, '0').toUpperCase(),
+        // binary按原始bit-string显示，便于与645页面展示口径保持一致。
+        binary: bitStringStatus?.binary || val16.toString(2).padStart(16, '0'),
+        bits: expandBits16(val16)
+    };
+}
 
-            setSuccessResult(result, {
-                timestamp: null,
-                statusWord: valTmp,
-                statusWordHex: valTmp.toString(16).padStart(4, '0').toUpperCase(),
-                statusBits: decodeMeterStatusBits(valTmp)
-            }, { generic: { dataType: 'bit-string' } });
+function parseStatusWordsFromAxdrArray(buffer) {
+    if (!Buffer.isBuffer(buffer) || buffer.length < 2 || buffer[0] !== 0x01) return [];
+    const L = readAxdrLength(buffer, 1);
+    const count = L.len;
+    let offset = 1 + L.size;
+    const words = [];
+
+    for (let i = 0; i < count && offset < buffer.length; i++) {
+        if (buffer[offset] === 0x04) {
+            const word = parseStatusWordFromAxdrBitString(buffer.slice(offset));
+            if (!word) break;
+            words.push(word);
+            offset += word.consumed;
         } else {
-            throw new Error("无法解析状态字");
+            const { consumed } = enhancedParseData(buffer.slice(offset), '2014', '02');
+            if (!consumed) break;
+            offset += consumed;
         }
-
-    } catch (e) {
-        console.error('parseMeterStatus错误:', e.message);
-        setErrorResult(result, e.message);
     }
 
-    return result;
+    return words;
 }
 
-
-/**
- * 解析电表运行状态字3（20140203）- 按操作类位义输出字段
- */
-function parseMeterStatusWord3(dataBuffer) {
-    const oad = '20140203';
-    const result = createStandardResult("电表运行状态字3", oad, dataBuffer);
+function parseMeterStatusWord698(dataBuffer, oad, dataType) {
+    const result = createStandardResult(dataType, oad, dataBuffer);
     try {
         const bitStringStatus = parseStatusWordFromAxdrBitString(dataBuffer);
         const statusWord = bitStringStatus?.statusWord ?? parseMeterStatusOptimized(dataBuffer);
         if (statusWord === null) throw new Error('无法解析状态字');
 
-        const val16 = statusWord & 0xFFFF; // 低16位
-        // binary按最终状态字数值输出(bit15..bit0)，与645状态字binary保持一致。
-        const bin = val16.toString(2).padStart(16, '0');
-
-        result.value = {
-            rawValue: val16,
-            binary: bin,
-            ...(bitStringStatus?.binaryLowToHigh ? { binaryLowToHigh: bitStringStatus.binaryLowToHigh } : {}),
-            ...(bitStringStatus?.binaryHighToLow ? { binaryHighToLow: bitStringStatus.binaryHighToLow } : {})
-        };
+        const value = format698StatusWord(statusWord, bitStringStatus);
+        result.value = value;
 
         setSuccessResult(result, {
-            statusWord: val16,
-            statusWordHex: val16.toString(16).padStart(4, '0').toUpperCase(),
-            statusBits: decodeMeterStatusBits(val16)
+            statusWord: value.rawValue,
+            statusWordHex: value.statusWordHex,
+            statusBits: decodeMeterStatusBits(value.rawValue)
         }, { generic: { dataType: 'bit-string' } });
     } catch (e) {
         setErrorResult(result, e.message);
     }
+
     return result;
 }
 
-/**
- * 解析电表运行状态字2（20140202）- 返回原始位数组，不强加语义
- */
-function parseMeterStatusWord2(dataBuffer) {
-    const oad = '20140202';
-    const result = createStandardResult("电表运行状态字2", oad, dataBuffer);
+function parseMeterStatusArray698(dataBuffer) {
+    const oad = '20140200';
+    const result = createStandardResult("电表状态", oad, dataBuffer);
     try {
-        const bitStringStatus = parseStatusWordFromAxdrBitString(dataBuffer);
-        const statusWord = bitStringStatus?.statusWord ?? parseMeterStatusOptimized(dataBuffer);
-        if (statusWord === null) throw new Error('无法解析状态字');
-
-        const val16 = statusWord & 0xFFFF;
-        // binary按最终状态字数值输出(bit15..bit0)，与645状态字binary保持一致。
-        const bin = val16.toString(2).padStart(16, '0');
+        const parsedWords = parseStatusWordsFromAxdrArray(dataBuffer);
+        if (!parsedWords.length) throw new Error('无法解析状态字数组');
 
+        const words = parsedWords.map((word, index) => format698StatusWord(word.statusWord, word, index + 1));
         result.value = {
-            rawValue: val16,
-            binary: bin,
-            ...(bitStringStatus?.binaryLowToHigh ? { binaryLowToHigh: bitStringStatus.binaryLowToHigh } : {}),
-            ...(bitStringStatus?.binaryHighToLow ? { binaryHighToLow: bitStringStatus.binaryHighToLow } : {}),
-            bits: decodeMeterStatusBits(val16)
+            word1: words[0] || null,
+            word2: words[1] || null,
+            word3: words[2] || null,
+            words
         };
 
-        setSuccessResult(result, { statusWord: val16, statusWordHex: val16.toString(16).padStart(4, '0').toUpperCase(), statusBits: decodeMeterStatusBits(val16) }, { generic: { dataType: 'bit-string' } });
+        setSuccessResult(result, {
+            statusWords: words,
+            statusWord: words[0]?.rawValue ?? null,
+            statusWordHex: words[0]?.statusWordHex ?? null,
+            statusBits: words[0] ? decodeMeterStatusBits(words[0].rawValue) : []
+        }, { generic: { dataType: 'array' } });
     } catch (e) {
         setErrorResult(result, e.message);
     }
+
     return result;
 }
 
+/**
+ * 解析电表运行状态字1或状态字数组
+ * @param {Buffer} dataBuffer - 数据缓冲区
+ * @returns {Object} 解析结果
+ */
+
+function parseMeterStatus(dataBuffer, oad = '20140201') {
+    if (oad === '20140200') return parseMeterStatusArray698(dataBuffer);
+    return parseMeterStatusWord698(dataBuffer, oad, "电表状态");
+}
+
+/**
+ * 解析电表运行状态字3（20140203）
+ */
+function parseMeterStatusWord3(dataBuffer) {
+    return parseMeterStatusWord698(dataBuffer, '20140203', "电表运行状态字3");
+}
+
+/**
+ * 解析电表运行状态字2（20140202）
+ */
+function parseMeterStatusWord2(dataBuffer) {
+    return parseMeterStatusWord698(dataBuffer, '20140202', "电表运行状态字2");
+}
+
 /**
  * 优化的状态字解析策略
  * @param {Buffer} dataBuffer - 数据缓冲区
@@ -1792,6 +1782,48 @@ function parseBatteryVoltage(dataBuffer, oad) {
     return result;
 }
 
+/**
+ * 解析时钟电池工作时间（分钟）
+ * @param {Buffer} dataBuffer - 数据缓冲区
+ * @param {string} oad - OAD标识
+ * @returns {Object} 解析结果
+ */
+function parseClockBatteryWorkTime(dataBuffer, oad) {
+    const oadInfo = getOADInfo(oad);
+    const result = createStandardResult(oadInfo ? oadInfo.desc : "时钟电池工作时间", oad, dataBuffer);
+
+    try {
+        const { result: genericResult } = enhancedParseData(dataBuffer, oad.slice(0, 4), oad.slice(4, 6));
+
+        if (genericResult.dataType !== '双长无符号整数' || typeof genericResult.parsedValue !== 'number') {
+            throw new Error(`时钟电池工作时间数据格式不正确: ${genericResult.dataType}`);
+        }
+
+        const rawMinutes = genericResult.parsedValue;
+        result.value = rawMinutes;
+
+        setSuccessResult(result, [{
+            type: oadInfo ? oadInfo.desc : "时钟电池工作时间",
+            rawValue: rawMinutes,
+            minutes: rawMinutes,
+            workMinutes: rawMinutes,
+            clock_battery_work_min: rawMinutes,
+            unit: "min",
+            description: `${oadInfo ? oadInfo.desc : "时钟电池工作时间"} ${rawMinutes}分钟`
+        }], {
+            unit: "min",
+            scale: 0,
+            count: 1,
+            generic: genericResult
+        });
+
+    } catch (e) {
+        setErrorResult(result, e.message);
+    }
+
+    return result;
+}
+
 function parseEnergyData(dataBuffer, oad) {
     const result = createStandardResult("电能数据", oad, dataBuffer);
     try {
@@ -2288,6 +2320,7 @@ function oadParserRouter(payload, oad) {
     if (oad === '40070205') return parseLCDDecimalDigits(payload); //抄读当前组合有功电能数据块
     if (oad === '20110200') return parseBatteryVoltage(payload, oad); // 时钟电池电压
     if (oad === '20120200') return parseBatteryVoltage(payload, oad); // 停电抄表电池电压
+    if (oad === '20130200') return parseClockBatteryWorkTime(payload, oad); // 时钟电池工作时间
     // 通用兜底
     const oadInfo = getOADInfo(oad) || { desc: "通用数据" };
     const genericStdResult = createStandardResult(oadInfo.desc, oad, payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-zelecproto",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "node-red zelecproto node",
   "main": "index.js",
   "scripts": {

package/AGENTS.md

@@ -1,133 +0,0 @@
-# AGENTS.md
-
-This file contains guidelines and commands for agentic coding agents working in the node-red-zelecproto repository.
-
-## Global Settings
-- **Proxy**: Execute `proxy` command before running any network-related commands to enable proxy connection
-
-## Build/Test/Lint Commands
-
-### Current Commands
-- `npm test` - Currently shows "Error: no test specified" (placeholder)
-- No build, lint, or typecheck commands are currently configured
-
-### Testing
-- Use `node test.js` to run the manual test file
-- Test file located at: `test.js`
-- For single test execution, run `node -e "require('./test.js')"`
-
-### Development
-- No build process required (Node-RED nodes load directly)
-- Manual testing via Node-RED flow editor recommended
-
-## Code Style Guidelines
-
-### File Structure and Naming
-- Main node files: `zelecproto.js`, `zbatchproto.js`, `zeleble.js`
-- Protocol implementations: `645.js`, `698.js`, `ble.js`
-- HTML definitions: `zelecproto.html`, `zbatchproto.html`, `zeleble.html`
-- Icons in: `icons/` directory (SVG format)
-- Use kebab-case for file names
-
-### Module Pattern
-All Node-RED nodes must follow this pattern:
-```javascript
-module.exports = function (RED) {
-    "use strict";
-    
-    // Require dependencies
-    var proto645 = require("./645");
-    
-    function NodeName(n) {
-        RED.nodes.createNode(this, n);
-        var node = this;
-        
-        this.on("input", function (msg, send, done) {
-            // Process message
-            send(msg);
-            done();
-        });
-        
-        this.on('close', () => {
-            // Cleanup if needed
-        });
-    }
-    
-    RED.nodes.registerType("nodename", NodeName);
-}
-```
-
-### Import/Require Style
-- Use `var` for requires (consistent with existing codebase)
-- Local dependencies first: `var proto645 = require("./645");`
-- Group requires at top of module function
-- Use relative paths for local files
-
-### Code Formatting
-- Use strict mode: `"use strict";` at top of module function
-- Indentation: 4 spaces (consistent with existing files)
-- Semicolons required
-- String quotes: single quotes preferred
-- Object property access: dot notation for known properties, bracket notation for dynamic
-
-### Naming Conventions
-- Node functions: PascalCase (e.g., `zelecproto`, `zbatchproto`)
-- Variables: camelCase (e.g., `msg`, `node`, `addrBytes`)
-- Constants: UPPER_SNAKE_CASE (e.g., `START`, `END`, `OAD`)
-- File names: kebab-case (e.g., `zelecproto.js`, `645.js`)
-
-### Error Handling
-- Use `throw new Error()` for validation errors
-- Include descriptive error messages
-- Validate input parameters before processing
-- Example: `if (addrRaw.length !== 12) throw new Error('com_exec_addr 必须是 6 字节(12个HEX字符)');`
-
-### Message Processing
-- Always use the three-parameter input handler: `function (msg, send, done)`
-- Call `send(msg)` before `done()`
-- Clean up temporary properties: `delete msg._proto`
-- Preserve original message structure when possible
-
-### Protocol Implementation
-- 645 Protocol: Focus on DL/T 645 frame building/parsing
-- 698 Protocol: DL/T 698.45 encode/decode with CRC-16/X-25
-- BLE Protocol: 国网多芯物联表蓝牙通信协议
-- Each protocol file should export a function that takes `msg` and returns modified `msg`
-
-### HTML Node Definitions
-- Use data-template-name attribute matching node type
-- Include name field in all nodes
-- Set appropriate category, color, and icon
-- Category: 'zutils' for all nodes
-- Icons: reference SVG files in icons/ directory
-
-### Comments and Documentation
-- Use Chinese comments for protocol-specific explanations (consistent with existing code)
-- Use JSDoc-style comments for functions
-- Include protocol references and frame format descriptions
-- Example: `// 国网多芯物联表《蓝牙通信及脉冲检定说明手册(0224)》协议`
-
-### Buffer/Hex Handling
-- Use `Buffer.from()` for creating buffers
-- Hex strings should be uppercase without spaces for final output
-- Use helper functions for hex/bytes conversion
-- Maintain consistent hex formatting across protocols
-
-### Node-RED Integration
-- Register nodes in package.json under `node-red.nodes`
-- Minimum Node.js version: >=15
-- Minimum Node-RED version: >=1.3
-- No external dependencies currently required
-
-## Development Workflow
-1. Modify protocol implementation files as needed
-2. Test with `node test.js` or via Node-RED flow editor
-3. Ensure all nodes follow the standard module pattern
-4. Verify HTML definitions match JavaScript node registrations
-5. Test message processing with sample data
-
-## Protocol-Specific Notes
-- 645: Handle address reversal and OAD encryption
-- 698: Implement CRC-16/X-25 checksum validation
-- BLE: Follow frame format with Start/End markers
-- All protocols should support both encode and decode operations