node-red-contrib-my-tools 1.0.0

package/node-red-contrib-s7-plus/lib/s7plus/pvar-lists.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const S7p = require('./s7p');
+
+const TAGDESCR_ATTRIBUTE2_OFFSETINFOTYPE = 0xf000;
+const OFFSETINFOTYPE_FB_ARRAY = 0;
+const OFFSETINFOTYPE_STRUCTELEM_STD = 1;
+const OFFSETINFOTYPE_STD = 8;
+const OFFSETINFOTYPE_STRING = 9;
+const OFFSETINFOTYPE_ARRAY1DIM = 10;
+const OFFSETINFOTYPE_ARRAYMDIM = 11;
+const OFFSETINFOTYPE_STRUCT = 12;
+const OFFSETINFOTYPE_STRUCT1DIM = 13;
+const OFFSETINFOTYPE_STRUCTMDIM = 14;
+const OFFSETINFOTYPE_FBSFB = 15;
+
+class POffsetInfoType {
+    constructor() {
+        this.optimizedAddress = 0;
+        this.nonoptimizedAddress = 0;
+    }
+    hasRelation() { return false; }
+    is1Dim() { return false; }
+    isMDim() { return false; }
+    getRelationId() { return 0; }
+    getArrayLowerBounds() { return 0; }
+    getArrayElementCount() { return 0; }
+    getMdimArrayLowerBounds() { return [0, 0, 0, 0, 0, 0]; }
+    getMdimArrayElementCount() { return [0, 0, 0, 0, 0, 0]; }
+
+    static deserialize(buf, offsetinfotype) {
+        switch (offsetinfotype) {
+            case OFFSETINFOTYPE_FB_ARRAY:
+                return POffsetInfoTypeFbArray.deserialize(buf);
+            case OFFSETINFOTYPE_STRUCTELEM_STD:
+            case OFFSETINFOTYPE_STD:
+                return POffsetInfoTypeStd.deserialize(buf, offsetinfotype);
+            case 2: // StructElemString
+            case OFFSETINFOTYPE_STRING:
+                return POffsetInfoTypeString.deserialize(buf);
+            case 3:
+            case OFFSETINFOTYPE_ARRAY1DIM:
+                return POffsetInfoTypeArray1Dim.deserialize(buf);
+            case 4:
+            case OFFSETINFOTYPE_ARRAYMDIM:
+                return POffsetInfoTypeArrayMDim.deserialize(buf);
+            case 5:
+            case OFFSETINFOTYPE_STRUCT:
+                return POffsetInfoTypeStruct.deserialize(buf);
+            case 6:
+            case OFFSETINFOTYPE_STRUCT1DIM:
+                return POffsetInfoTypeStruct1Dim.deserialize(buf);
+            case 7:
+            case OFFSETINFOTYPE_STRUCTMDIM:
+                return POffsetInfoTypeStructMDim.deserialize(buf);
+            case OFFSETINFOTYPE_FBSFB:
+                return POffsetInfoTypeFbSfb.deserialize(buf);
+            default:
+                return { oi: new POffsetInfoType(), n: 0 };
+        }
+    }
+}
+
+class POffsetInfoTypeStd extends POffsetInfoType {
+    static deserialize(buf, offsetinfotype) {
+        const oi = new POffsetInfoTypeStd();
+        let r;
+        if (offsetinfotype === OFFSETINFOTYPE_STD) {
+            r = S7p.decodeUInt16LE(buf);
+            oi.optimizedAddress = r.v;
+            r = S7p.decodeUInt16LE(buf);
+            oi.nonoptimizedAddress = r.v;
+        } else {
+            r = S7p.decodeUInt16LE(buf);
+            oi.nonoptimizedAddress = r.v;
+            r = S7p.decodeUInt16LE(buf);
+            oi.optimizedAddress = r.v;
+        }
+        return { oi, n: r.n + (offsetinfotype === OFFSETINFOTYPE_STD ? 2 : 2) };
+    }
+}
+
+class POffsetInfoTypeString extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeString();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeArray1Dim extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeArray1Dim();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeInt32LE(buf); oi.arrayLowerBounds = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.arrayElementCount = r.v; n += r.n;
+        oi.is1Dim = () => true;
+        oi.getArrayLowerBounds = () => oi.arrayLowerBounds;
+        oi.getArrayElementCount = () => oi.arrayElementCount;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeArrayMDim extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeArrayMDim();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeInt32LE(buf); oi.arrayLowerBounds = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.arrayElementCount = r.v; n += r.n;
+        oi.mdimArrayLowerBounds = [];
+        oi.mdimArrayElementCount = [];
+        for (let d = 0; d < 6; d++) {
+            r = S7p.decodeInt32LE(buf); oi.mdimArrayLowerBounds[d] = r.v; n += r.n;
+        }
+        for (let d = 0; d < 6; d++) {
+            r = S7p.decodeUInt32LE(buf); oi.mdimArrayElementCount[d] = r.v; n += r.n;
+        }
+        oi.isMDim = () => true;
+        oi.getArrayLowerBounds = () => oi.arrayLowerBounds;
+        oi.getArrayElementCount = () => oi.arrayElementCount;
+        oi.getMdimArrayLowerBounds = () => oi.mdimArrayLowerBounds;
+        oi.getMdimArrayElementCount = () => oi.mdimArrayElementCount;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeStruct extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeStruct();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.relationId = r.v; n += r.n;
+        for (let i = 0; i < 4; i++) { r = S7p.decodeUInt32LE(buf); n += r.n; }
+        oi.hasRelation = () => true;
+        oi.getRelationId = () => oi.relationId;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeStruct1Dim extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeStruct1Dim();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeInt32LE(buf); oi.arrayLowerBounds = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.arrayElementCount = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.relationId = r.v; n += r.n;
+        for (let i = 0; i < 4; i++) { r = S7p.decodeUInt32LE(buf); n += r.n; }
+        oi.is1Dim = () => true;
+        oi.hasRelation = () => true;
+        oi.getRelationId = () => oi.relationId;
+        oi.getArrayLowerBounds = () => oi.arrayLowerBounds;
+        oi.getArrayElementCount = () => oi.arrayElementCount;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeStructMDim extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeStructMDim();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeInt32LE(buf); oi.arrayLowerBounds = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.arrayElementCount = r.v; n += r.n;
+        oi.mdimArrayLowerBounds = [];
+        oi.mdimArrayElementCount = [];
+        for (let d = 0; d < 6; d++) {
+            r = S7p.decodeInt32LE(buf); oi.mdimArrayLowerBounds[d] = r.v; n += r.n;
+        }
+        for (let d = 0; d < 6; d++) {
+            r = S7p.decodeUInt32LE(buf); oi.mdimArrayElementCount[d] = r.v; n += r.n;
+        }
+        r = S7p.decodeUInt32LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.relationId = r.v; n += r.n;
+        for (let i = 0; i < 4; i++) { r = S7p.decodeUInt32LE(buf); n += r.n; }
+        oi.isMDim = () => true;
+        oi.hasRelation = () => true;
+        oi.getRelationId = () => oi.relationId;
+        oi.getArrayLowerBounds = () => oi.arrayLowerBounds;
+        oi.getArrayElementCount = () => oi.arrayElementCount;
+        oi.getMdimArrayLowerBounds = () => oi.mdimArrayLowerBounds;
+        oi.getMdimArrayElementCount = () => oi.mdimArrayElementCount;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeFbSfb extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeFbSfb();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.relationId = r.v; n += r.n;
+        for (let i = 0; i < 6; i++) { r = S7p.decodeUInt32LE(buf); n += r.n; }
+        oi.hasRelation = () => true;
+        oi.getRelationId = () => oi.relationId;
+        return { oi, n };
+    }
+}
+
+class POffsetInfoTypeFbArray extends POffsetInfoType {
+    static deserialize(buf) {
+        const oi = new POffsetInfoTypeFbArray();
+        let n = 0;
+        let r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt16LE(buf); n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.optimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.nonoptimizedAddress = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); oi.relationId = r.v; n += r.n;
+        for (let i = 0; i < 10; i++) { r = S7p.decodeUInt32LE(buf); n += r.n; }
+        for (let d = 0; d < 6; d++) { r = S7p.decodeInt32LE(buf); n += r.n; }
+        for (let d = 0; d < 6; d++) { r = S7p.decodeUInt32LE(buf); n += r.n; }
+        oi.hasRelation = () => true;
+        oi.getRelationId = () => oi.relationId;
+        return { oi, n };
+    }
+}
+
+class PVartypeListElement {
+    constructor() {
+        this.lid = 0;
+        this.symbolCrc = 0;
+        this.softdatatype = 0;
+        this.attributeFlags = 0;
+        this.bitoffsetinfoFlags = 0;
+        this.offsetInfoType = new POffsetInfoType();
+    }
+
+    deserialize(buf) {
+        let n = 0;
+        let r = S7p.decodeUInt32LE(buf); this.lid = r.v; n += r.n;
+        r = S7p.decodeUInt32LE(buf); this.symbolCrc = r.v; n += r.n;
+        r = S7p.decodeByte(buf); this.softdatatype = r.v; n += r.n;
+        r = S7p.decodeUInt16(buf); this.attributeFlags = r.v; n += r.n;
+        const offsetinfotype = (this.attributeFlags & TAGDESCR_ATTRIBUTE2_OFFSETINFOTYPE) >> 12;
+        r = S7p.decodeByte(buf); this.bitoffsetinfoFlags = r.v; n += r.n;
+        const des = POffsetInfoType.deserialize(buf, offsetinfotype);
+        this.offsetInfoType = des.oi;
+        n += des.n;
+        return n;
+    }
+}
+
+class PVartypeList {
+    constructor() {
+        this.elements = [];
+        this.firstId = 0;
+    }
+
+    deserialize(buf) {
+        let n = 0;
+        let r = S7p.decodeUInt16(buf);
+        let blocklen = r.v;
+        n += r.n;
+        let maxret = n + blocklen;
+        r = S7p.decodeUInt32LE(buf);
+        this.firstId = r.v;
+        n += r.n;
+        while (blocklen > 0) {
+            do {
+                const elem = new PVartypeListElement();
+                n += elem.deserialize(buf);
+                this.elements.push(elem);
+            } while (n < maxret);
+            r = S7p.decodeUInt16(buf);
+            blocklen = r.v;
+            n += r.n;
+            maxret = n + blocklen;
+        }
+        return n;
+    }
+}
+
+class PVarnameList {
+    constructor() {
+        this.names = [];
+    }
+
+    deserialize(buf) {
+        let n = 0;
+        let r = S7p.decodeUInt16(buf);
+        let blocklen = r.v;
+        n += r.n;
+        let maxret = n + blocklen;
+        while (blocklen > 0) {
+            do {
+                r = S7p.decodeByte(buf);
+                const namelen = r.v;
+                n += r.n;
+                r = S7p.decodeWString(buf, namelen);
+                this.names.push(r.v);
+                n += r.n;
+                r = S7p.decodeByte(buf);
+                n += r.n;
+            } while (n < maxret);
+            r = S7p.decodeUInt16(buf);
+            blocklen = r.v;
+            n += r.n;
+            maxret = n + blocklen;
+        }
+        return n;
+    }
+}
+
+module.exports = {
+    PVartypeList,
+    PVartypeListElement,
+    PVarnameList,
+    POffsetInfoType
+};

package/node-red-contrib-s7-plus/lib/s7plus/read-result.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const { errorText, S7Consts } = require('./constants');
+
+function readTagErrorText(err) {
+    if (!err || err === 0n) return 'OK';
+    if (err <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        const n = Number(err);
+        const text = errorText(n);
+        if (text !== `CLI: Unknown error (0x${(n >>> 0).toString(16)})`) {
+            return text;
+        }
+    }
+    return `PLC: Read error (0x${err.toString(16)})`;
+}
+
+function buildReadTagStatus(err) {
+    if (!err || err === 0n) {
+        return { status: 'ok', error: '' };
+    }
+    return { status: 'error', error: readTagErrorText(err) };
+}
+
+function writeTagErrorText(err) {
+    if (!err || err === 0n) return 'OK';
+    if (err <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        const n = Number(err);
+        const text = errorText(n);
+        if (text !== `CLI: Unknown error (0x${(n >>> 0).toString(16)})`) {
+            return text;
+        }
+    }
+    return `PLC: Write error (0x${err.toString(16)})`;
+}
+
+function buildReadPayload(prepared, rawValues, errors, decodeReadValue) {
+    const result = {};
+    for (let i = 0; i < prepared.length; i++) {
+        const name = prepared[i].tag.name || `tag${i}`;
+        const err = errors[i];
+        const tagStatus = buildReadTagStatus(err);
+        if (tagStatus.status === 'ok') {
+            const softdatatype = prepared[i].tag.datatype || undefined;
+            result[name] = { value: decodeReadValue(rawValues[i], softdatatype), ...tagStatus };
+        } else {
+            result[name] = { value: null, ...tagStatus };
+        }
+    }
+    return result;
+}
+
+function buildWriteTagStatus(err) {
+    if (!err || err === 0n) {
+        return { status: 'ok', error: '' };
+    }
+    return { status: 'error', error: writeTagErrorText(err) };
+}
+
+/**
+ * Build a per-tag write result keyed by tag name, mirroring buildReadPayload.
+ * On success the written value is echoed back; on error the value is null,
+ * exactly like the read payload.
+ */
+function buildWritePayload(tags, errors) {
+    const result = {};
+    for (let i = 0; i < tags.length; i++) {
+        const name = tags[i].name || `tag${i}`;
+        const tagStatus = buildWriteTagStatus(errors[i]);
+        result[name] = tagStatus.status === 'ok'
+            ? { value: tags[i].value, ...tagStatus }
+            : { value: null, ...tagStatus };
+    }
+    return result;
+}
+
+function formatOutputPayload(result, order, format) {
+    if (format !== 'array') return result;
+    return order
+        .filter((symbol) => Object.prototype.hasOwnProperty.call(result, symbol))
+        .map((symbol) => ({ symbol, ...result[symbol] }));
+}
+
+module.exports = {
+    readTagErrorText,
+    writeTagErrorText,
+    buildReadTagStatus,
+    buildReadPayload,
+    buildWriteTagStatus,
+    buildWritePayload,
+    formatOutputPayload
+};

package/node-red-contrib-s7-plus/lib/s7plus/s7p.js

@@ -0,0 +1,266 @@
+'use strict';
+
+const { Ids } = require('./constants');
+
+const S7p = {
+    encodeByte(buf, v) { return buf.writeByte(v); },
+    encodeUInt16(buf, v) {
+        buf.writeByte((v & 0xff00) >> 8);
+        buf.writeByte(v & 0xff);
+        return 2;
+    },
+    encodeUInt32(buf, v) {
+        buf.writeByte((v >>> 24) & 0xff);
+        buf.writeByte((v >>> 16) & 0xff);
+        buf.writeByte((v >>> 8) & 0xff);
+        buf.writeByte(v & 0xff);
+        return 4;
+    },
+    encodeUInt64(buf, v) {
+        const n = BigInt(v);
+        // Unsigned 64-bit wire field: a negative or oversized value would be
+        // silently re-encoded as its two's-complement bit pattern (e.g. a
+        // pre-1970 LDT turning into year 2554). Reject it loudly instead.
+        if (n < 0n || n > 0xffffffffffffffffn) {
+            throw new Error(`encodeUInt64: value ${n} out of unsigned 64-bit range (0 .. 2^64-1)`);
+        }
+        const hi = Number((n >> 32n) & 0xffffffffn);
+        const lo = Number(n & 0xffffffffn);
+        S7p.encodeUInt32(buf, hi);
+        S7p.encodeUInt32(buf, lo);
+        return 8;
+    },
+    encodeInt32Vlq(buf, value) {
+        const b = [];
+        let absV;
+        if (value === -2147483648) absV = 2147483648;
+        else absV = Math.abs(value);
+        b[0] = value & 0x7f;
+        let length = 1;
+        for (let i = 1; i < 5; i++) {
+            if (absV >= 0x40) {
+                length++;
+                absV >>>= 7;
+                value >>= 7;
+                b[i] = (value & 0x7f) + 0x80;
+            } else break;
+        }
+        for (let i = length - 1; i >= 0; i--) buf.writeByte(b[i]);
+        return length;
+    },
+    encodeUInt32Vlq(buf, value) {
+        const bytes = [];
+        let i;
+        for (i = 4; i > 0; i--) {
+            if (value & (0x7f << (i * 7))) break;
+        }
+        for (let j = 0; j <= i; j++) {
+            bytes[j] = ((value >> ((i - j) * 7)) & 0x7f) | 0x80;
+        }
+        bytes[i] ^= 0x80;
+        buf.writeBytes(Buffer.from(bytes.slice(0, i + 1)));
+        return i + 1;
+    },
+    encodeUInt64Vlq(buf, value) {
+        const b = [];
+        let val = BigInt(value);
+        const special = val > 0x00ffffffffffffffn;
+        if (special) b[0] = Number(val & 0xffn);
+        else b[0] = Number(val & 0x7fn);
+        let length = 1;
+        for (let i = 1; i < 9; i++) {
+            if (val >= 0x80n) {
+                length++;
+                if (i === 1 && special) val >>= 8n;
+                else val >>= 7n;
+                b[i] = Number(val & 0x7fn) + 0x80;
+            } else break;
+        }
+        if (special && length === 8) {
+            length++;
+            b[8] = 0x80;
+        }
+        for (let i = length - 1; i >= 0; i--) buf.writeByte(b[i]);
+        return length;
+    },
+    encodeFloat(buf, value) {
+        const v = Buffer.alloc(4);
+        v.writeFloatLE(value, 0);
+        buf.writeByte(v[3]);
+        buf.writeByte(v[2]);
+        buf.writeByte(v[1]);
+        buf.writeByte(v[0]);
+        return 4;
+    },
+    encodeDouble(buf, value) {
+        const v = Buffer.alloc(8);
+        v.writeDoubleLE(value, 0);
+        for (let i = 7; i >= 0; i--) buf.writeByte(v[i]);
+        return 8;
+    },
+
+    decodeByte(buf) {
+        const v = buf.readByte();
+        return v === null ? { n: 0, v: 0 } : { n: 1, v };
+    },
+    decodeUInt16(buf) {
+        const a = buf.readByte();
+        const b = buf.readByte();
+        if (a === null || b === null) return { n: 0, v: 0 };
+        return { n: 2, v: (a << 8) | b };
+    },
+    decodeUInt32(buf) {
+        const a = buf.readByte(); const b = buf.readByte();
+        const c = buf.readByte(); const d = buf.readByte();
+        if (d === null) return { n: 0, v: 0 };
+        return { n: 4, v: ((a << 24) | (b << 16) | (c << 8) | d) >>> 0 };
+    },
+    decodeInt16(buf) {
+        const r = S7p.decodeUInt16(buf);
+        let v = r.v;
+        if (v & 0x8000) v -= 0x10000;
+        return { n: r.n, v };
+    },
+    decodeUInt64(buf) {
+        const hi = S7p.decodeUInt32(buf);
+        const lo = S7p.decodeUInt32(buf);
+        return { n: 8, v: (BigInt(hi.v) << 32n) | BigInt(lo.v) };
+    },
+    decodeInt64(buf) {
+        const r = S7p.decodeUInt64(buf);
+        let v = r.v;
+        if (v >= 0x8000000000000000n) v -= 0x10000000000000000n;
+        return { n: 8, v };
+    },
+    decodeUInt16LE(buf) {
+        const a = buf.readByte(); const b = buf.readByte();
+        if (b === null) return { n: 0, v: 0 };
+        return { n: 2, v: (a | (b << 8)) & 0xffff };
+    },
+    decodeUInt32LE(buf) {
+        const a = buf.readByte(); const b = buf.readByte();
+        const c = buf.readByte(); const d = buf.readByte();
+        if (d === null) return { n: 0, v: 0 };
+        return { n: 4, v: (a | (b << 8) | (c << 16) | (d << 24)) >>> 0 };
+    },
+    decodeInt32LE(buf) {
+        const r = S7p.decodeUInt32LE(buf);
+        let v = r.v;
+        if (v & 0x80000000) v = v - 0x100000000;
+        return { n: r.n, v };
+    },
+    decodeWString(buf, len) {
+        const bytes = buf.readBytes(len);
+        if (!bytes) return { n: 0, v: '' };
+        return { n: len, v: bytes.toString('utf8') };
+    },
+    decodeUInt32Vlq(buf) {
+        let val = 0;
+        let length = 0;
+        for (let counter = 1; counter <= 5; counter++) {
+            const octet = buf.readByte();
+            if (octet === null) break;
+            length++;
+            val <<= 7;
+            const cont = octet & 0x80;
+            val += octet & 0x7f;
+            if (cont === 0) break;
+        }
+        return { n: length, v: val >>> 0 };
+    },
+    decodeInt32Vlq(buf) {
+        let val = 0;
+        let length = 0;
+        for (let counter = 1; counter <= 5; counter++) {
+            let octet = buf.readByte();
+            if (octet === null) break;
+            length++;
+            if (counter === 1 && (octet & 0x40)) {
+                octet &= 0xbf;
+                val = -64;
+            } else val <<= 7;
+            const cont = octet & 0x80;
+            val += octet & 0x7f;
+            if (cont === 0) break;
+        }
+        return { n: length, v: val | 0 };
+    },
+    decodeUInt64Vlq(buf) {
+        let val = 0n;
+        let length = 0;
+        let cont = 0;
+        let octet = 0;
+        for (let counter = 1; counter <= 8; counter++) {
+            octet = buf.readByte();
+            if (octet === null) break;
+            length++;
+            val <<= 7n;
+            cont = octet & 0x80;
+            val += BigInt(octet & 0x7f);
+            if (cont === 0) break;
+        }
+        if (cont > 0) {
+            octet = buf.readByte();
+            if (octet !== null) {
+                length++;
+                val <<= 8n;
+                val += BigInt(octet);
+            }
+        }
+        return { n: length, v: val };
+    },
+    decodeInt64Vlq(buf) {
+        let val = 0n;
+        let length = 0;
+        let cont = 0;
+        let octet = 0;
+        for (let counter = 1; counter <= 8; counter++) {
+            octet = buf.readByte();
+            if (octet === null) break;
+            length++;
+            if (counter === 1 && (octet & 0x40)) {
+                octet &= 0xbf;
+                val = -64n;
+            } else val <<= 7n;
+            cont = octet & 0x80;
+            val += BigInt(octet & 0x7f);
+            if (cont === 0) break;
+        }
+        if (cont > 0) {
+            octet = buf.readByte();
+            if (octet !== null) {
+                length++;
+                val <<= 8n;
+                val += BigInt(octet);
+            }
+        }
+        return { n: length, v: val };
+    },
+    decodeFloat(buf) {
+        const v = Buffer.alloc(4);
+        v[3] = buf.readByte();
+        v[2] = buf.readByte();
+        v[1] = buf.readByte();
+        v[0] = buf.readByte();
+        return { n: 4, v: v.readFloatLE(0) };
+    },
+    decodeDouble(buf) {
+        const v = Buffer.alloc(8);
+        for (let i = 7; i >= 0; i--) v[i] = buf.readByte();
+        return { n: 8, v: v.readDoubleLE(0) };
+    },
+    decodeHeader(buf) {
+        buf.readByte();
+        const ver = buf.readByte();
+        const len = S7p.decodeUInt16(buf);
+        return { version: ver, length: len.v };
+    },
+    encodeHeader(buf, version, length) {
+        buf.writeByte(0x72);
+        buf.writeByte(version);
+        S7p.encodeUInt16(buf, length);
+        return 4;
+    }
+};
+
+module.exports = S7p;