node-red-contrib-my-tools 1.0.0

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

@@ -0,0 +1,397 @@
+'use strict';
+
+const { Ids } = require('../constants');
+const { MEMORY_AREAS } = require('./areas');
+const { encodeNodeId } = require('./node-id');
+const {
+    eNodeType,
+    softdatatypeName,
+    isSoftdatatypeSupported,
+    isPackedLeafDatatype,
+    getSizeOfDatatype
+} = require('./datatypes');
+
+const ARRAY_PAGE_SIZE = 32;
+
+/**
+ * Lazy browse: one tree level at a time, arrays as single node or paginated indices.
+ * exploreChildsRecursive=0 on PLC; fallback loads subtree from cache (see client).
+ */
+
+function pathNames(path) {
+    return path.map(p => p.name).join('');
+}
+
+function pathAccess(path) {
+    let accessIds = '';
+    for (const p of path) {
+        if (p.nodeType === eNodeType.Root) {
+            accessIds += p.accessId.toString(16).toUpperCase();
+        } else {
+            accessIds += '.' + p.accessId.toString(16).toUpperCase();
+            if (p.nodeType === eNodeType.StructArray) accessIds += '.1';
+        }
+    }
+    return accessIds;
+}
+
+function publicNode(id, label, nodeKind, hasChildren, datatype, isLeaf) {
+    return { id, label, nodeKind, hasChildren, datatype: datatype || undefined, isLeaf: !!isLeaf };
+}
+
+function resolveTypeName(cache, relationId, fallbackSoftdatatype) {
+    const ob = relationId ? cache.get(relationId) || null : null;
+    if (ob && typeof ob.getAttribute === 'function') {
+        const nameAttr = ob.getAttribute(Ids.ObjectVariableTypeName);
+        if (nameAttr) return String(nameAttr.toJs());
+    }
+    return softdatatypeName(fallbackSoftdatatype);
+}
+
+function listBlockRoots(dbList) {
+    const nodes = [];
+    for (const ed of dbList) {
+        if (!ed.db_block_ti_relid) continue;
+        const path = [{
+            nodeType: eNodeType.Root,
+            name: ed.db_name,
+            accessId: ed.db_block_relid,
+            tiRelId: ed.db_block_ti_relid
+        }];
+        nodes.push(publicNode(
+            encodeNodeId({ t: 'block', path, tiRelId: ed.db_block_ti_relid }),
+            ed.db_name,
+            'block',
+            true,
+            undefined,
+            false
+        ));
+    }
+    for (const a of MEMORY_AREAS) {
+        const path = [{ nodeType: eNodeType.Root, name: a.name, accessId: a.accessId, tiRelId: a.tiRelId }];
+        nodes.push(publicNode(
+            encodeNodeId({ t: 'block', path, tiRelId: a.tiRelId }),
+            a.name,
+            'area',
+            true,
+            undefined,
+            false
+        ));
+    }
+    return nodes;
+}
+
+function listMembersForTypeInfo(typeOb, parentPath, cache) {
+    const nodes = [];
+    if (!typeOb || !typeOb.vartypeList) return nodes;
+
+    let elementIndex = 0;
+    for (const vte of typeOb.vartypeList.elements) {
+        const name = typeOb.varnameList.names[elementIndex];
+        const oit = vte.offsetInfoType;
+        const path = parentPath.concat([{
+            nodeType: eNodeType.Var,
+            name: '.' + name,
+            accessId: vte.lid,
+            softdatatype: vte.softdatatype,
+            vte
+        }]);
+
+        if (oit.is1Dim && oit.is1Dim()) {
+            const count = oit.getArrayElementCount();
+            const lower = oit.getArrayLowerBounds();
+            const hasRel = oit.hasRelation();
+            const relId = hasRel ? oit.getRelationId() : 0;
+            const dtName = hasRel
+                ? resolveTypeName(cache, relId, vte.softdatatype)
+                : softdatatypeName(vte.softdatatype);
+            const desc = {
+                t: 'array',
+                path,
+                elementIndex,
+                lower,
+                count,
+                hasRelation: hasRel,
+                relationId: relId
+            };
+            nodes.push(publicNode(
+                encodeNodeId(desc),
+                name,
+                'array',
+                count > 0,
+                `Array[${lower}..${lower + count - 1}] of ${dtName}`,
+                false
+            ));
+        } else if (oit.isMDim && oit.isMDim()) {
+            const count = oit.getArrayElementCount();
+            const hasRel = oit.hasRelation();
+            const relId = hasRel ? oit.getRelationId() : 0;
+            const dtName = hasRel
+                ? resolveTypeName(cache, relId, vte.softdatatype)
+                : softdatatypeName(vte.softdatatype);
+            const desc = {
+                t: 'array',
+                path,
+                elementIndex,
+                lower: 0,
+                count,
+                mdim: true,
+                hasRelation: hasRel,
+                relationId: relId
+            };
+            nodes.push(publicNode(
+                encodeNodeId(desc),
+                name,
+                'array',
+                count > 0,
+                `Array[${count}] of ${dtName}`,
+                false
+            ));
+        } else if (oit.hasRelation && oit.hasRelation() && !isPackedLeafDatatype(vte.softdatatype)) {
+            const relId = oit.getRelationId();
+            const childOb = relId ? cache.get(relId) || null : null;
+            const desc = { t: 'struct', path, tiRelId: relId };
+            nodes.push(publicNode(
+                encodeNodeId(desc),
+                name,
+                'struct',
+                !!(childOb && childOb.vartypeList) || relId !== 0,
+                resolveTypeName(cache, relId, vte.softdatatype),
+                false
+            ));
+        } else if (isSoftdatatypeSupported(vte.softdatatype)) {
+            const desc = { t: 'leaf', path };
+            nodes.push(publicNode(
+                encodeNodeId(desc),
+                name,
+                'leaf',
+                false,
+                softdatatypeName(vte.softdatatype),
+                true
+            ));
+        } else {
+            const desc = { t: 'unsupported', path };
+            nodes.push(publicNode(
+                encodeNodeId(desc),
+                name,
+                'unsupported',
+                false,
+                softdatatypeName(vte.softdatatype),
+                false
+            ));
+        }
+        elementIndex++;
+    }
+    return nodes;
+}
+
+function listArrayPages(desc, cache) {
+    const { lower, count } = desc;
+    const nodes = [];
+    const lastSeg = desc.path[desc.path.length - 1];
+    const dtLabel = desc.hasRelation
+        ? resolveTypeName(cache, desc.relationId, lastSeg.softdatatype)
+        : softdatatypeName(lastSeg.softdatatype);
+    for (let start = 0; start < count; start += ARRAY_PAGE_SIZE) {
+        const end = Math.min(start + ARRAY_PAGE_SIZE - 1, count - 1);
+        const label = `[${lower + start}..${lower + end}]`;
+        const pageDesc = {
+            t: 'arrpage',
+            path: desc.path,
+            lower: desc.lower,
+            count: desc.count,
+            hasRelation: desc.hasRelation,
+            relationId: desc.relationId,
+            mdim: desc.mdim,
+            start,
+            end
+        };
+        nodes.push(publicNode(
+            encodeNodeId(pageDesc),
+            label,
+            'arrpage',
+            true,
+            dtLabel,
+            false
+        ));
+    }
+    return nodes;
+}
+
+function listArrayElements(pageDesc, cache) {
+    const vte = pageDesc.path[pageDesc.path.length - 1].vte;
+    const nodes = [];
+    const parentPath = pageDesc.path;
+
+    for (let i = pageDesc.start; i <= pageDesc.end; i++) {
+        const elemName = `[${pageDesc.lower + i}]`;
+
+        if (pageDesc.hasRelation) {
+            const arrayPath = parentPath.concat([{
+                nodeType: eNodeType.StructArray,
+                name: elemName,
+                accessId: i,
+                softdatatype: vte.softdatatype,
+                vte
+            }]);
+            const desc = {
+                t: 'struct',
+                path: arrayPath,
+                tiRelId: pageDesc.relationId,
+                arrayIndex: i
+            };
+            nodes.push(publicNode(
+                encodeNodeId(desc),
+                elemName,
+                'struct',
+                true,
+                resolveTypeName(cache, pageDesc.relationId, vte.softdatatype),
+                false
+            ));
+        } else {
+            const tcomSize = getSizeOfDatatype(vte);
+            const arrayPath = parentPath.concat([{
+                nodeType: eNodeType.Array,
+                name: elemName,
+                accessId: i,
+                softdatatype: vte.softdatatype,
+                vte,
+                arrayAdrOffsetOpt: i * tcomSize,
+                arrayAdrOffsetNonOpt: i * tcomSize
+            }]);
+            if (isSoftdatatypeSupported(vte.softdatatype)) {
+                const leafDesc = { t: 'leaf', path: arrayPath };
+                nodes.push(publicNode(
+                    encodeNodeId(leafDesc),
+                    elemName,
+                    'leaf',
+                    false,
+                    softdatatypeName(vte.softdatatype),
+                    true
+                ));
+            } else {
+                nodes.push(publicNode(
+                    encodeNodeId({ t: 'unsupported', path: arrayPath }),
+                    elemName,
+                    'unsupported',
+                    false,
+                    softdatatypeName(vte.softdatatype),
+                    false
+                ));
+            }
+        }
+    }
+    return nodes;
+}
+
+function listChildren(desc, cache) {
+    switch (desc.t) {
+        case 'block':
+        case 'struct': {
+            const typeOb = desc.tiRelId ? cache.get(desc.tiRelId) || null : null;
+            if (!typeOb) return [];
+            const parentPath = desc.path || [];
+            return listMembersForTypeInfo(typeOb, parentPath, cache);
+        }
+        case 'array':
+            return listArrayPages(desc, cache);
+        case 'arrpage':
+            return listArrayElements(desc, cache);
+        default:
+            return [];
+    }
+}
+
+function resolveLeaf(desc) {
+    if (desc.t === 'unsupported') throw new Error('Datatype not supported for symbolic access');
+    if (desc.t !== 'leaf') throw new Error('Node is not a leaf symbol');
+    const name = pathNames(desc.path);
+    const address = pathAccess(desc.path);
+    const sd = desc.path[desc.path.length - 1].softdatatype;
+
+    const crcMeta = buildCrcMeta(desc.path);
+
+    return {
+        name,
+        address,
+        datatype: softdatatypeName(sd),
+        crcMeta
+    };
+}
+
+// Robust accessor: works both on a live POffsetInfoType* instance (has
+// getArrayLowerBounds method) and on a plain object recovered from
+// JSON.stringify/parse (encodeNodeId path) where methods are lost but
+// the underlying data field arrayLowerBounds survives. Without this
+// fallback CRC computation for arrays whose lower bound differs from 0
+// (e.g. TIA `Array[1..N]`) silently produces lowerBound=0 and the PLC
+// rejects the read with 0x8009890012cbffef (CRC mismatch).
+function oitLowerBound(oit) {
+    if (!oit) return 0;
+    if (typeof oit.getArrayLowerBounds === 'function') return oit.getArrayLowerBounds() | 0;
+    if (typeof oit.arrayLowerBounds === 'number') return oit.arrayLowerBounds | 0;
+    return 0;
+}
+
+function buildCrcMeta(path) {
+    const STRUCT_SD = 17;
+    const segments = [];
+
+    for (let i = 1; i < path.length; i++) {
+        const seg = path[i];
+        const isArrayElem = seg.nodeType === eNodeType.Array
+            || seg.nodeType === eNodeType.StructArray;
+
+        if (isArrayElem) {
+            const arraySeg = path[i - 1];
+            const rawName = arraySeg.name.startsWith('.') ? arraySeg.name.slice(1) : arraySeg.name;
+            const vte = arraySeg.vte;
+            const oit = vte ? vte.offsetInfoType : null;
+            const lower = oitLowerBound(oit);
+            if (segments.length > 0 && segments[segments.length - 1].memberName === rawName) {
+                segments[segments.length - 1] = {
+                    memberName: rawName,
+                    softdatatype: arraySeg.softdatatype,
+                    isArray: true,
+                    elementSoftdatatype: seg.softdatatype,
+                    lowerBound: lower
+                };
+            } else {
+                segments.push({
+                    memberName: rawName,
+                    softdatatype: arraySeg.softdatatype,
+                    isArray: true,
+                    elementSoftdatatype: seg.softdatatype,
+                    lowerBound: lower
+                });
+            }
+        } else if (seg.nodeType === eNodeType.Var) {
+            const rawName = seg.name.startsWith('.') ? seg.name.slice(1) : seg.name;
+            segments.push({
+                memberName: rawName,
+                softdatatype: seg.softdatatype,
+                isArray: false,
+                elementSoftdatatype: 0,
+                lowerBound: 0
+            });
+        }
+    }
+
+    if (segments.length === 0) {
+        return { memberName: '', softdatatype: 0, isArray: false, elementSoftdatatype: 0, lowerBound: 0, pathSegments: [] };
+    }
+
+    if (segments.length === 1) {
+        return segments[0];
+    }
+
+    return { pathSegments: segments };
+}
+
+module.exports = {
+    ARRAY_PAGE_SIZE,
+    listBlockRoots,
+    listChildren,
+    resolveLeaf,
+    resolveTypeName
+};

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

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Stable node ids for lazy PLC browse (base64url JSON descriptors).
+ */
+
+function encodeNodeId(descriptor) {
+    return Buffer.from(JSON.stringify(descriptor), 'utf8').toString('base64url');
+}
+
+function decodeNodeId(nodeId) {
+    if (!nodeId || typeof nodeId !== 'string') {
+        throw new Error('Invalid browse node id');
+    }
+    try {
+        return JSON.parse(Buffer.from(nodeId, 'base64url').toString('utf8'));
+    } catch {
+        throw new Error('Invalid browse node id');
+    }
+}
+
+module.exports = { encodeNodeId, decodeNodeId };

package/node-red-contrib-s7-plus/lib/s7plus/browse/resolve-symbolic.js

@@ -0,0 +1,181 @@
+'use strict';
+
+/**
+ * Resolve a symbolic PLC path (e.g. "DB1.readings[0]") by walking
+ * the browse tree. Handles quoted DB names, arrays with index notation,
+ * and struct nesting.
+ */
+
+/**
+ * Parse a TIA-Portal-style symbol path into segments, splitting array
+ * indices into separate segments.
+ * "DB1.readings[0]"     -> ['DB1', 'readings', '[0]']
+ * '"DB Name".struct.x'      -> ['DB Name', 'struct', 'x']
+ * "DB1.arr[3].member"       -> ['DB1', 'arr', '[3]', 'member']
+ */
+function parseSymbolSegments(symbolPath) {
+    const segments = [];
+    let i = 0;
+    while (i < symbolPath.length) {
+        if (symbolPath[i] === '"') {
+            const end = symbolPath.indexOf('"', i + 1);
+            if (end === -1) {
+                segments.push(symbolPath.slice(i + 1));
+                break;
+            }
+            segments.push(symbolPath.slice(i + 1, end));
+            i = end + 1;
+            if (i < symbolPath.length && symbolPath[i] === '.') i++;
+        } else if (symbolPath[i] === '[') {
+            const end = symbolPath.indexOf(']', i);
+            if (end === -1) {
+                segments.push(symbolPath.slice(i));
+                break;
+            }
+            segments.push(symbolPath.slice(i, end + 1));
+            i = end + 1;
+            if (i < symbolPath.length && symbolPath[i] === '.') i++;
+        } else {
+            let end = symbolPath.length;
+            for (let j = i; j < symbolPath.length; j++) {
+                if (symbolPath[j] === '.' || symbolPath[j] === '[') {
+                    end = j;
+                    break;
+                }
+            }
+            const seg = symbolPath.slice(i, end);
+            if (seg) segments.push(seg);
+            i = end;
+            if (i < symbolPath.length && symbolPath[i] === '.') i++;
+        }
+    }
+    return segments;
+}
+
+/**
+ * Navigate the browse tree to find a node by label among children,
+ * transparently expanding arrpage nodes for array index segments.
+ */
+async function findChildByLabel(client, parentId, label) {
+    const { nodes: children } = await client.browseChildren(parentId);
+
+    const direct = children.find(n => n.label === label);
+    if (direct) return direct;
+
+    for (const child of children) {
+        if (child.nodeKind === 'arrpage') {
+            const { nodes: pageElements } = await client.browseChildren(child.id);
+            const match = pageElements.find(n => n.label === label);
+            if (match) return match;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Walk the browse tree along a symbolic path and resolve the leaf node.
+ * @param {object} client - S7CommPlusClient instance
+ * @param {string} symbolPath - e.g. "DB1.readings[0]"
+ * @returns {Promise<{name, address, datatype, crcMeta}>}
+ */
+async function resolveSymbolicPath(client, symbolPath) {
+    const segments = parseSymbolSegments(symbolPath);
+    if (segments.length < 2) {
+        throw new Error(`Invalid symbolic path: '${symbolPath}' (need at least DB.member)`);
+    }
+
+    const { nodes: roots } = await client.browseRoots();
+    const rootNode = roots.find(n => n.label === segments[0]);
+    if (!rootNode) {
+        throw new Error(`Symbol root '${segments[0]}' not found among PLC roots`);
+    }
+
+    let current = rootNode;
+    for (let i = 1; i < segments.length; i++) {
+        if (!current.hasChildren) {
+            throw new Error(
+                `Symbol segment '${segments[i]}' not reachable — '${current.label}' has no children`
+            );
+        }
+        const next = await findChildByLabel(client, current.id, segments[i]);
+        if (!next) {
+            throw new Error(
+                `Symbol segment '${segments[i]}' not found in '${current.label}'`
+            );
+        }
+        current = next;
+    }
+
+    if (!current.isLeaf) {
+        throw new Error(`Symbol path '${symbolPath}' does not resolve to a readable leaf symbol`);
+    }
+
+    return client.browseResolve(current.id);
+}
+
+/**
+ * Batch-resolve multiple symbolic paths sharing a single browseRootsCached()
+ * call and the accumulated type-info cache. Each symbol is resolved
+ * independently so a failure in one does not block the others.
+ * @param {object} client - S7CommPlusClient instance
+ * @param {string[]} symbolPaths - e.g. ["DB1.speed", "DB2.temp"]
+ * @returns {Promise<Array<{name, address, datatype, crcMeta} | {error: string}>>}
+ */
+async function resolveSymbolicBatch(client, symbolPaths) {
+    const { nodes: roots } = await client.browseRootsCached();
+    const results = [];
+
+    for (const symbolPath of symbolPaths) {
+        try {
+            const segments = parseSymbolSegments(symbolPath);
+            if (segments.length < 2) {
+                results.push({ error: `Invalid symbolic path: '${symbolPath}' (need at least DB.member)` });
+                continue;
+            }
+
+            const rootNode = roots.find(n => n.label === segments[0]);
+            if (!rootNode) {
+                results.push({ error: `Symbol root '${segments[0]}' not found among PLC roots` });
+                continue;
+            }
+
+            let current = rootNode;
+            let failed = false;
+            for (let i = 1; i < segments.length; i++) {
+                if (!current.hasChildren) {
+                    results.push({
+                        error: `Symbol segment '${segments[i]}' not reachable — '${current.label}' has no children`
+                    });
+                    failed = true;
+                    break;
+                }
+                const next = await findChildByLabel(client, current.id, segments[i]);
+                if (!next) {
+                    results.push({
+                        error: `Symbol segment '${segments[i]}' not found in '${current.label}'`
+                    });
+                    failed = true;
+                    break;
+                }
+                current = next;
+            }
+            if (failed) continue;
+
+            if (!current.isLeaf) {
+                results.push({
+                    error: `Symbol path '${symbolPath}' does not resolve to a readable leaf symbol`
+                });
+                continue;
+            }
+
+            results.push(await client.browseResolve(current.id));
+        } catch (e) {
+            results.push({ error: e.message });
+        }
+    }
+
+    return results;
+}
+
+module.exports = { resolveSymbolicPath, parseSymbolSegments, resolveSymbolicBatch };

package/node-red-contrib-s7-plus/lib/s7plus/browse/vte-helpers.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const TAGDESCR_ATTRIBUTE2_BITOFFSET = 0x0007;
+const BITOFFSETINFO_CLASSIC = 0x08;
+const BITOFFSETINFO_NONOPTBITOFFSET = 0x70;
+const BITOFFSETINFO_OPTBITOFFSET = 0x07;
+
+function getAttributeBitoffset(vte) {
+    return (vte.attributeFlags || 0) & TAGDESCR_ATTRIBUTE2_BITOFFSET;
+}
+
+function getBitoffsetinfoFlagClassic(vte) {
+    return ((vte.bitoffsetinfoFlags || 0) & BITOFFSETINFO_CLASSIC) !== 0;
+}
+
+function getBitoffsetinfoNonoptimizedBitoffset(vte) {
+    return ((vte.bitoffsetinfoFlags || 0) & BITOFFSETINFO_NONOPTBITOFFSET) >> 4;
+}
+
+function getBitoffsetinfoOptimizedBitoffset(vte) {
+    return (vte.bitoffsetinfoFlags || 0) & BITOFFSETINFO_OPTBITOFFSET;
+}
+
+function applyBoolBitoffsets(info, vte) {
+    const BOOL = 1;
+    const BBOOL = 40;
+    if (vte.softdatatype === BOOL) {
+        info.optBitoffset = getAttributeBitoffset(vte);
+        if (getBitoffsetinfoFlagClassic(vte)) {
+            info.nonOptBitoffset = getBitoffsetinfoNonoptimizedBitoffset(vte);
+        } else {
+            info.nonOptBitoffset = getAttributeBitoffset(vte);
+        }
+    } else if (vte.softdatatype === BBOOL) {
+        info.optBitoffset = getBitoffsetinfoOptimizedBitoffset(vte);
+        info.nonOptBitoffset = 0;
+    } else {
+        info.optBitoffset = 0;
+        info.nonOptBitoffset = 0;
+    }
+}
+
+module.exports = {
+    getAttributeBitoffset,
+    getBitoffsetinfoFlagClassic,
+    getBitoffsetinfoNonoptimizedBitoffset,
+    getBitoffsetinfoOptimizedBitoffset,
+    applyBoolBitoffsets
+};