node-red-contrib-my-tools 1.0.0

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

@@ -0,0 +1,155 @@
+'use strict';
+
+const Opcode = {
+    Request: 0x31,
+    Response: 0x32,
+    Notification: 0x33,
+    Response2: 0x02
+};
+
+const Functioncode = {
+    Error: 0x04b1,
+    Explore: 0x04bb,
+    CreateObject: 0x04ca,
+    DeleteObject: 0x04d4,
+    SetVariable: 0x04f2,
+    GetVariable: 0x04fc,
+    SetMultiVariables: 0x0542,
+    GetMultiVariables: 0x054c,
+    GetVarSubStreamed: 0x0586,
+    InitSsl: 0x05b3
+};
+
+const ProtocolVersion = {
+    V1: 0x01,
+    V2: 0x02,
+    V3: 0x03,
+    SystemEvent: 0xfe
+};
+
+const ElementID = {
+    StartOfObject: 0xa1,
+    TerminatingObject: 0xa2,
+    Attribute: 0xa3,
+    Relation: 0xa4,
+    VartypeList: 0xab,
+    VarnameList: 0xac
+};
+
+const Datatype = {
+    Null: 0x00,
+    Bool: 0x01,
+    USInt: 0x02,
+    UInt: 0x03,
+    UDInt: 0x04,
+    ULInt: 0x05,
+    SInt: 0x06,
+    Int: 0x07,
+    DInt: 0x08,
+    LInt: 0x09,
+    Byte: 0x0a,
+    Word: 0x0b,
+    DWord: 0x0c,
+    LWord: 0x0d,
+    Real: 0x0e,
+    LReal: 0x0f,
+    Timestamp: 0x10,
+    Timespan: 0x11,
+    RID: 0x12,
+    AID: 0x13,
+    Blob: 0x14,
+    WString: 0x15,
+    Struct: 0x17
+};
+
+const Ids = {
+    None: 0,
+    ObjectRoot: 201,
+    GetNewRIDOnServer: 211,
+    ObjectVariableTypeName: 233,
+    Block_BlockNumber: 2521,
+    ASObjectES_Comment: 4288,
+    NativeObjects_thePLCProgram_Rid: 3,
+    ClassSubscriptions: 255,
+    ClassOMSTypeInfoContainer: 534,
+    ObjectOMSTypeInfoContainer: 537,
+    TI_TComSize: 1502,
+    PLCProgram_Class_Rid: 2520,
+    DB_Class_Rid: 2574,
+    ClassServerSessionContainer: 284,
+    ObjectServerSessionContainer: 285,
+    ClassServerSession: 287,
+    ObjectNullServerSession: 288,
+    ServerSessionClientRID: 300,
+    ServerSessionRequest: 303,
+    ServerSessionResponse: 304,
+    ServerSessionVersion: 306,
+    LID_SessionVersionSystemPAOMString: 319,
+    SystemLimits: 1037,
+    Legitimate: 1846,
+    EffectiveProtectionLevel: 1842,
+    ObjectQualifier: 1256,
+    ParentRID: 1257,
+    CompositionAID: 1258,
+    KeyQualifier: 1259,
+    DB_ValueActual: 2550,
+    ControllerArea_ValueActual: 3736,
+    NativeObjects_theS7Timers_Rid: 84,
+    NativeObjects_theS7Counters_Rid: 83,
+    NativeObjects_theIArea_Rid: 80,
+    NativeObjects_theQArea_Rid: 81,
+    NativeObjects_theMArea_Rid: 82,
+    LID_LegitimationPayloadStruct: 40400,
+    LID_LegitimationPayloadType: 40401,
+    LID_LegitimationPayloadUsername: 40402,
+    LID_LegitimationPayloadPassword: 40403
+};
+
+const AccessLevel = {
+    FullAccess: 1
+};
+
+const S7Consts = {
+    errTCPConnectionTimeout: 0x00010000,
+    errTCPConnectionFailed: 0x00010001,
+    errTCPDataReceive: 0x00010004,
+    errTCPNotConnected: 0x00010007,
+    errIsoConnect: 0x00020000,
+    errIsoInvalidPDU: 0x00020001,
+    errOpenSSL: 0x00030000,
+    errCliInvalidParams: 0x00200000,
+    errCliAccessDenied: 0x0020000f,
+    errCliFirmwareNotSupported: 0x0020001a,
+    errCliDeviceNotSupported: 0x0020001b,
+    errCliNeedPassword: 0x0020000d
+};
+
+function errorText(code) {
+    const map = {
+        0: 'OK',
+        [S7Consts.errTCPConnectionTimeout]: 'TCP: Connection Timeout',
+        [S7Consts.errTCPConnectionFailed]: 'TCP: Connection Error',
+        [S7Consts.errTCPDataReceive]: 'TCP: Data receive Timeout',
+        [S7Consts.errTCPNotConnected]: 'CLI: Client not connected',
+        [S7Consts.errIsoConnect]: 'ISO: Connection Error',
+        [S7Consts.errIsoInvalidPDU]: 'ISO: Invalid PDU',
+        [S7Consts.errOpenSSL]: 'TLS/SSL: Error',
+        [S7Consts.errCliAccessDenied]: 'CPU: Access denied',
+        [S7Consts.errCliFirmwareNotSupported]: 'CLI: Firmware not supported',
+        [S7Consts.errCliDeviceNotSupported]: 'CLI: Device not supported',
+        [S7Consts.errCliNeedPassword]: 'CPU: Password required'
+    };
+    return map[code] || `CLI: Unknown error (0x${(code >>> 0).toString(16)})`;
+}
+
+module.exports = {
+    Opcode,
+    Functioncode,
+    ProtocolVersion,
+    ElementID,
+    Datatype,
+    Ids,
+    AccessLevel,
+    S7Consts,
+    errorText
+};

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

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./symbol-crc');

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

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * S7CommPlus CRC32 - used for SymbolCRC in ItemAddress of read/write requests.
+ *
+ * Polynomial: 0xF4ACFB13 (MSB-first, non-reflected)
+ * Init: 0, Final XOR: none
+ *
+ * Informed by HarpoS7 (https://github.com/bonk-dev/HarpoS7, Copyright (c) 2024 bonk, MIT).
+ * Wireshark S7CommPlus dissector used as an additional protocol reference.
+ *
+ */
+
+const POLY = 0xF4ACFB13;
+
+const TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let crc = (i << 24) >>> 0;
+    for (let j = 0; j < 8; j++) {
+        if (crc & 0x80000000) {
+            crc = ((crc << 1) ^ POLY) >>> 0;
+        } else {
+            crc = (crc << 1) >>> 0;
+        }
+    }
+    TABLE[i] = crc >>> 0;
+}
+
+class S7CRC32 {
+    constructor() {
+        this.state = 0;
+    }
+
+    get result() {
+        return this.state >>> 0;
+    }
+
+    updateByte(b) {
+        this.state = (TABLE[(b ^ (this.state >>> 24)) & 0xFF] ^ ((this.state << 8) >>> 0)) >>> 0;
+    }
+
+    update(input) {
+        // Symbol/member names must be hashed over their UTF-8 byte
+        // representation, exactly as the PLC stores and transmits them
+        // (PVarnameList uses a byte-length prefix + UTF-8 payload). Using
+        // latin1 here would produce a wrong SymbolCRC for any non-ASCII
+        // name (e.g. an umlaut "ä" is 0xC3 0xA4 in UTF-8 vs. 0xE4 in
+        // latin1), which the PLC rejects with a CRC-mismatch read error.
+        const buf = typeof input === 'string' ? Buffer.from(input, 'utf8') : input;
+        for (let i = 0; i < buf.length; i++) {
+            this.updateByte(buf[i]);
+        }
+        return this;
+    }
+
+    updateUInt32LE(value) {
+        this.updateByte(value & 0xFF);
+        this.updateByte((value >>> 8) & 0xFF);
+        this.updateByte((value >>> 16) & 0xFF);
+        this.updateByte((value >>> 24) & 0xFF);
+        return this;
+    }
+
+    reset() {
+        this.state = 0;
+        return this;
+    }
+}
+
+module.exports = { S7CRC32, TABLE, POLY };

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

@@ -0,0 +1,271 @@
+'use strict';
+
+/**
+ * Compute the ItemAddress SymbolCRC for S7CommPlus read/write requests.
+ *
+ * The CRC identifies a symbol path so the PLC can verify the client
+ * is accessing the intended symbol even if LIDs have shifted after
+ * a program download.
+ *
+ * Algorithm (verified against S7-1500 FW):
+ *   1. innerCrc = CRC(memberName + typeInfo)
+ *   2. result   = new CRC().updateUInt32LE(innerCrc)
+ *
+ * TypeInfo encoding (appended to member name):
+ *   - Simple types: 1 byte TypeCode
+ *   - Arrays:       0x10 + elementTypeCode(1) + lowerBound(4 LE)
+ *   - Structs:      0x11
+ *
+ * For nested struct members the CRC chains hierarchically:
+ *   parentCrc → updateUInt32LE(parentCrc) → updateByte(0x89) → updateUInt32LE(childCrc)
+ *
+ * TypeCodes (S7-1500, scope Default):
+ *   Bool=0x01, Byte=0x02, Char=0x03, Word=0x04, Int=0x05, DWord=0x06,
+ *   DInt=0x07, Real=0x08, Date=0x09, TimeOfDay=0x0A, Time=0x0B,
+ *   S5Time=0x0C, DateAndTime=0x0E, Array=0x10, Struct=0x11, String=0x13,
+ *   LReal=0x30, ULInt=0x31, LInt=0x32, LWord=0x33, USInt=0x34, UInt=0x35,
+ *   UDInt=0x36, SInt=0x37, WChar=0x3D, WString=0x3E, LTime=0x40,
+ *   LTimeOfDay=0x41
+ */
+
+const { S7CRC32 } = require('./s7-crc32');
+
+const STRUCT_CHILD_DELIMITER = 0x89;
+
+const TypeCode = Object.freeze({
+    Bool: 0x01,
+    Byte: 0x02,
+    Char: 0x03,
+    Word: 0x04,
+    Int: 0x05,
+    DWord: 0x06,
+    DInt: 0x07,
+    Real: 0x08,
+    Date: 0x09,
+    TimeOfDay: 0x0A,
+    Time: 0x0B,
+    S5Time: 0x0C,
+    DateAndTime: 0x0E,
+    Array: 0x10,
+    Struct: 0x11,
+    String: 0x13,
+    LReal: 0x30,
+    ULInt: 0x31,
+    LInt: 0x32,
+    LWord: 0x33,
+    USInt: 0x34,
+    UInt: 0x35,
+    UDInt: 0x36,
+    SInt: 0x37,
+    WChar: 0x3D,
+    WString: 0x3E,
+    LTime: 0x40,
+    LTimeOfDay: 0x41
+});
+
+/**
+ * Map softdatatype (from PVartypeListElement) → TypeCode for CRC computation.
+ * The softdatatype values used by the S7-1500 firmware in TypeInfo responses
+ * happen to align with the CRC TypeCodes for most types.
+ */
+const SOFTDATATYPE_TO_TYPECODE = Object.freeze({
+    1: TypeCode.Bool,
+    2: TypeCode.Byte,
+    3: TypeCode.Char,
+    4: TypeCode.Word,
+    5: TypeCode.Int,
+    6: TypeCode.DWord,
+    7: TypeCode.DInt,
+    8: TypeCode.Real,
+    9: TypeCode.Date,
+    10: TypeCode.TimeOfDay,
+    11: TypeCode.Time,
+    12: TypeCode.S5Time,
+    14: TypeCode.DateAndTime,
+    17: TypeCode.Struct,
+    19: TypeCode.String,
+    40: TypeCode.Bool,
+    48: TypeCode.LReal,
+    49: TypeCode.ULInt,
+    50: TypeCode.LInt,
+    51: TypeCode.LWord,
+    52: TypeCode.USInt,
+    53: TypeCode.UInt,
+    54: TypeCode.UDInt,
+    55: TypeCode.SInt,
+    61: TypeCode.WChar,
+    62: TypeCode.WString,
+    64: TypeCode.LTime,
+    65: TypeCode.LTimeOfDay,
+
+    // Hardware / system softdatatypes → CRC TypeCode of underlying storage type
+    // 32-bit types (DWord): AOM_IDENT, EVENT_*
+    128: TypeCode.DWord,   // AOM_IDENT
+    129: TypeCode.DWord,   // EVENT_ANY
+    130: TypeCode.DWord,   // EVENT_ATT
+    131: TypeCode.DWord,   // EVENT_HWINT
+    132: TypeCode.DWord,   // FOLDER
+    133: TypeCode.DWord,   // AOM_AID
+    134: TypeCode.DWord,   // AOM_LINK
+
+    // 16-bit Word types: HW_*, CONN_ANY/PRG/OUC
+    144: TypeCode.Word,    // HW_ANY
+    145: TypeCode.Word,    // HW_IOSYSTEM
+    146: TypeCode.Word,    // HW_DPMASTER
+    147: TypeCode.Word,    // HW_DEVICE
+    148: TypeCode.Word,    // HW_DPSLAVE
+    149: TypeCode.Word,    // HW_IO
+    150: TypeCode.Word,    // HW_MODULE
+    151: TypeCode.Word,    // HW_SUBMODULE
+    152: TypeCode.Word,    // HW_HSC
+    153: TypeCode.Word,    // HW_PWM
+    154: TypeCode.Word,    // HW_PTO
+    155: TypeCode.Word,    // HW_INTERFACE
+    156: TypeCode.Word,    // HW_IEPORT
+    168: TypeCode.Word,    // CONN_ANY
+    169: TypeCode.Word,    // CONN_PRG
+    170: TypeCode.Word,    // CONN_OUC
+    171: TypeCode.DWord,   // CONN_R_ID (32-bit)
+
+    // 16-bit Int types: OB_* (OB numbers are signed Int per TIA Portal)
+    160: TypeCode.Int,     // OB_ANY
+    161: TypeCode.Int,     // OB_DELAY
+    162: TypeCode.Int,     // OB_TOD
+    163: TypeCode.Int,     // OB_CYCLIC
+    164: TypeCode.Int,     // OB_ATT
+    192: TypeCode.Int,     // OB_PCYCLE
+    193: TypeCode.Int,     // OB_HWINT
+    195: TypeCode.Int,     // OB_DIAG
+    196: TypeCode.Int,     // OB_TIMEERROR
+    197: TypeCode.Int,     // OB_STARTUP
+
+    // 16-bit UInt types: DB_*, PORT, RTM, PIP
+    173: TypeCode.UInt,    // PORT
+    174: TypeCode.UInt,    // RTM
+    175: TypeCode.UInt,    // PIP
+    208: TypeCode.UInt,    // DB_ANY
+    209: TypeCode.UInt,    // DB_WWW
+    210: TypeCode.UInt     // DB_DYN
+});
+
+function softdatatypeToTypeCode(sd) {
+    return SOFTDATATYPE_TO_TYPECODE[sd] || sd;
+}
+
+/**
+ * Compute the inner CRC for a single member (name + type info).
+ * @param {string} name - member name (UTF-8)
+ * @param {number} typeCode - TypeCode byte
+ * @param {object} [arrayInfo] - { elementTypeCode, lowerBound } for arrays
+ * @returns {number} raw CRC (before double-hash)
+ */
+function memberInnerCrc(name, typeCode, arrayInfo) {
+    const crc = new S7CRC32();
+    crc.update(name);
+    if (typeCode === TypeCode.Array && arrayInfo) {
+        crc.updateByte(TypeCode.Array);
+        crc.updateByte(arrayInfo.elementTypeCode & 0xFF);
+        const lb = Buffer.alloc(4);
+        lb.writeInt32LE(arrayInfo.lowerBound || 0);
+        crc.update(lb);
+    } else {
+        crc.updateByte(typeCode & 0xFF);
+    }
+    return crc.result;
+}
+
+/**
+ * Double-hash: wrap an inner CRC into the final ItemAddress CRC format.
+ * @param {number} innerCrc
+ * @returns {number}
+ */
+function finalizeItemCrc(innerCrc) {
+    const crc = new S7CRC32();
+    crc.updateUInt32LE(innerCrc);
+    return crc.result;
+}
+
+/**
+ * Compute ItemAddress SymbolCRC for a direct DB member (no struct nesting).
+ * @param {string} name - member name
+ * @param {number} typeCode - TypeCode byte
+ * @param {object} [arrayInfo] - { elementTypeCode, lowerBound }
+ * @returns {number}
+ */
+function computeItemCrc(name, typeCode, arrayInfo) {
+    return finalizeItemCrc(memberInnerCrc(name, typeCode, arrayInfo));
+}
+
+/**
+ * Compute ItemAddress SymbolCRC for a struct-nested member.
+ * @param {Array<{name: string, typeCode: number, arrayInfo?: object}>} pathSegments
+ *   Ordered from outermost struct to leaf member.
+ * @returns {number}
+ */
+function computeNestedItemCrc(pathSegments) {
+    if (pathSegments.length === 0) return 0;
+    if (pathSegments.length === 1) {
+        const s = pathSegments[0];
+        return computeItemCrc(s.name, s.typeCode, s.arrayInfo);
+    }
+
+    const first = pathSegments[0];
+    const crc = new S7CRC32();
+    crc.updateUInt32LE(memberInnerCrc(first.name, first.typeCode, first.arrayInfo));
+
+    for (let i = 1; i < pathSegments.length; i++) {
+        crc.updateByte(STRUCT_CHILD_DELIMITER);
+        const seg = pathSegments[i];
+        crc.updateUInt32LE(memberInnerCrc(seg.name, seg.typeCode, seg.arrayInfo));
+    }
+
+    return crc.result;
+}
+
+/**
+ * Compute ItemAddress SymbolCRC directly from browse crcMeta.
+ * Supports single members, arrays, and nested struct paths.
+ * @param {object} crcMeta - as returned by resolveLeaf().crcMeta
+ * @returns {number}
+ */
+function computeCrcFromMeta(crcMeta) {
+    if (!crcMeta) return 0;
+
+    if (crcMeta.pathSegments) {
+        return computeNestedItemCrc(crcMeta.pathSegments.map(seg => {
+            if (seg.isArray) {
+                return {
+                    name: seg.memberName,
+                    typeCode: TypeCode.Array,
+                    arrayInfo: {
+                        elementTypeCode: softdatatypeToTypeCode(seg.elementSoftdatatype),
+                        lowerBound: seg.lowerBound || 0
+                    }
+                };
+            }
+            return { name: seg.memberName, typeCode: softdatatypeToTypeCode(seg.softdatatype) };
+        }));
+    }
+
+    if (!crcMeta.memberName) return 0;
+    if (crcMeta.isArray) {
+        return computeItemCrc(crcMeta.memberName, TypeCode.Array, {
+            elementTypeCode: softdatatypeToTypeCode(crcMeta.elementSoftdatatype),
+            lowerBound: crcMeta.lowerBound || 0
+        });
+    }
+    const tc = softdatatypeToTypeCode(crcMeta.softdatatype);
+    return computeItemCrc(crcMeta.memberName, tc);
+}
+
+module.exports = {
+    S7CRC32,
+    TypeCode,
+    STRUCT_CHILD_DELIMITER,
+    softdatatypeToTypeCode,
+    memberInnerCrc,
+    finalizeItemCrc,
+    computeItemCrc,
+    computeNestedItemCrc,
+    computeCrcFromMeta
+};

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

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * Tiny scope-aware debug logger.
+ *
+ * Activation:
+ *   - environment variable `S7P_DEBUG`:
+ *       `1` / `true` / `*`     enable all scopes
+ *       `client,endpoint`      enable only listed scopes (comma-separated)
+ *   - programmatic: `require('./debug').setEnabled('client,transport')`
+ *
+ * Output goes to stderr via `console.error` so it surfaces in the Node-RED
+ * log without interfering with stdout-based protocols.
+ */
+
+const SCOPE_PREFIX = 's7p';
+let enabledScopes = parseScopes(process.env.S7P_DEBUG || '');
+let sink = (line) => { try { console.error(line); } catch { /* ignore */ } };
+
+function parseScopes(spec) {
+    if (!spec) return new Set();
+    const s = String(spec).trim().toLowerCase();
+    if (s === '0' || s === 'false' || s === 'off') return new Set();
+    if (s === '1' || s === 'true' || s === '*' || s === 'all') return new Set(['*']);
+    return new Set(s.split(',').map(x => x.trim()).filter(Boolean));
+}
+
+function setEnabled(spec) {
+    enabledScopes = parseScopes(spec);
+}
+
+function isEnabled(scope) {
+    if (!enabledScopes.size) return false;
+    if (enabledScopes.has('*')) return true;
+    return enabledScopes.has(String(scope).toLowerCase());
+}
+
+function setSink(fn) {
+    sink = typeof fn === 'function' ? fn : sink;
+}
+
+function ts() {
+    const d = new Date();
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    const ms = String(d.getMilliseconds()).padStart(3, '0');
+    return `${hh}:${mm}:${ss}.${ms}`;
+}
+
+function fmtValue(v) {
+    if (v == null) return String(v);
+    if (typeof v === 'bigint') return `${v}n`;
+    if (typeof v === 'number') return Number.isFinite(v) ? String(v) : 'NaN';
+    if (typeof v === 'string') return v;
+    if (Buffer.isBuffer(v)) return `<Buffer ${v.length}b ${v.subarray(0, 16).toString('hex')}${v.length > 16 ? '…' : ''}>`;
+    if (v instanceof Error) return v.message;
+    try { return JSON.stringify(v); } catch { return String(v); }
+}
+
+/**
+ * Lazily resolve a debug record so we never pay the formatting cost when
+ * the scope is disabled. Accepts either positional args or a thunk:
+ *   debug('client', 'connect', { host });
+ *   debug('client', () => ['connect', { host }]);
+ */
+function debug(scope, ...args) {
+    if (!isEnabled(scope)) return;
+    let parts = args;
+    if (parts.length === 1 && typeof parts[0] === 'function') {
+        try { parts = parts[0]() || []; } catch (e) { parts = [`<debug-thunk-error: ${e.message}>`]; }
+        if (!Array.isArray(parts)) parts = [parts];
+    }
+    const head = `[${SCOPE_PREFIX}:${scope}] ${ts()}`;
+    const tail = parts.map(fmtValue).join(' ');
+    sink(`${head} ${tail}`);
+}
+
+/**
+ * Convenience scoped logger:
+ *   const log = require('./debug').scoped('client');
+ *   log('connect', { host });
+ */
+function scoped(scope) {
+    return (...args) => debug(scope, ...args);
+}
+
+module.exports = { debug, scoped, setEnabled, isEnabled, setSink };

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

@@ -0,0 +1,41 @@
+'use strict';
+
+const VALID_SYMBOL_INFOS = new Set(['none', 'object', 'array']);
+
+function normalizeSymbolInfos(mode) {
+    if (typeof mode === 'string' && VALID_SYMBOL_INFOS.has(mode)) return mode;
+    return 'none';
+}
+
+function stripSymbolName(entry) {
+    const { name, ...info } = entry;
+    return info;
+}
+
+function formatExplorePayload(rawSymbols, symbolInfos) {
+    const mode = normalizeSymbolInfos(symbolInfos);
+    const symbols = rawSymbols.map(s => s.name);
+
+    if (mode === 'none') {
+        return { symbols };
+    }
+
+    if (mode === 'object') {
+        const infos = {};
+        for (const entry of rawSymbols) {
+            infos[entry.name] = stripSymbolName(entry);
+        }
+        return { symbols, infos };
+    }
+
+    const infos = rawSymbols.map(entry => ({
+        symbol: entry.name,
+        ...stripSymbolName(entry)
+    }));
+    return { symbols, infos };
+}
+
+module.exports = {
+    normalizeSymbolInfos,
+    formatExplorePayload
+};

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

@@ -0,0 +1,55 @@
+'use strict';
+
+const S7p = require('./s7p');
+const { Ids } = require('./constants');
+
+class ItemAddress {
+    constructor(accessAreaOrString, accessSubArea) {
+        this.symbolCrc = 0;
+        this.lid = [];
+        if (typeof accessAreaOrString === 'string') {
+            const parts = accessAreaOrString.split('.');
+            const ids = parts.map(p => parseInt(p, 16));
+            this.accessArea = ids[0];
+            if (this.accessArea >= 0x8a0e0000) {
+                this.accessSubArea = Ids.DB_ValueActual;
+            } else if ([
+                Ids.NativeObjects_theS7Timers_Rid,
+                Ids.NativeObjects_theS7Counters_Rid,
+                Ids.NativeObjects_theIArea_Rid,
+                Ids.NativeObjects_theQArea_Rid,
+                Ids.NativeObjects_theMArea_Rid
+            ].includes(this.accessArea)) {
+                this.accessSubArea = Ids.ControllerArea_ValueActual;
+            } else {
+                this.accessSubArea = accessSubArea ?? Ids.DB_ValueActual;
+            }
+            for (let i = 1; i < ids.length; i++) this.lid.push(ids[i]);
+        } else {
+            this.accessArea = accessAreaOrString ?? 0;
+            this.accessSubArea = accessSubArea ?? Ids.DB_ValueActual;
+        }
+    }
+
+    getNumberOfFields() {
+        return 4 + this.lid.length;
+    }
+
+    serialize(buf) {
+        let n = 0;
+        n += S7p.encodeUInt32Vlq(buf, this.symbolCrc);
+        n += S7p.encodeUInt32Vlq(buf, this.accessArea >>> 0);
+        n += S7p.encodeUInt32Vlq(buf, this.lid.length + 1);
+        n += S7p.encodeUInt32Vlq(buf, this.accessSubArea >>> 0);
+        for (const id of this.lid) n += S7p.encodeUInt32Vlq(buf, id >>> 0);
+        return n;
+    }
+
+    getAccessString() {
+        let s = this.accessArea.toString(16).toUpperCase();
+        for (const i of this.lid) s += `.${i.toString(16).toUpperCase()}`;
+        return s;
+    }
+}
+
+module.exports = ItemAddress;