@vitormnm/node-red-simple-opcua 1.5.0 → 1.6.2

package/client/lib/opcua-client-read-service.js

@@ -1,13 +1,25 @@
 "use strict";
 
-const { dataValueToItemResult, resolveNodeId } = require("../opcua-client-utils");
+const { dataValueToItemResult, resolveNodeId, enrichItemResultWithEnumeration } = require("../opcua-client-utils");
 
 class OpcUaClientReadService {
     async execute(node, msg, session, itemsResolver) {
         const items = itemsResolver.ensureClientItems(node, msg, "OPC UA read");
         const nodeIds = items.map((item) => resolveNodeId(item));
         const values = await session.readVariableValue(nodeIds);
-        return values.map((dataValue, index) => dataValueToItemResult(items[index], dataValue));
+        
+        const cache = new Map();
+        const results = [];
+        
+        for (let index = 0; index < values.length; index++) {
+            const dataValue = values[index];
+            const item = items[index];
+            let result = dataValueToItemResult(item, dataValue);
+            result = await enrichItemResultWithEnumeration(result, session, cache, nodeIds[index]);
+            results.push(result);
+        }
+        
+        return results;
     }
 }
 

package/client/lib/opcua-client-subscription-service.js

@@ -11,6 +11,7 @@ const {
 const {
     dataValueToItemResult,
     dataValueToItemResultEvent,
+    enrichItemResultWithEnumeration,
     resolveName,
     resolveNodeId,
     statusCodeToString
@@ -49,8 +50,11 @@ class OpcUaClientSubscriptionService {
                 TimestampsToReturn.Both
             );
 
-            monitoredItem.on("changed", (dataValue) => {
-                const payload = dataValueToItemResult(item, dataValue);
+            const cache = new Map();
+            monitoredItem.on("changed", async (dataValue) => {
+                let payload = dataValueToItemResult(item, dataValue);
+                payload = await enrichItemResultWithEnumeration(payload, session, cache, resolveNodeId(item));
+                
                 node.status({
                     fill: "blue",
                     shape: "dot",
@@ -108,7 +112,8 @@ class OpcUaClientSubscriptionService {
             "ActiveState",
             "AckedState",
             "ConfirmedState",
-            "Time"
+            "Time",
+            "ConditionId"
         ]);
 
         node.monitoredItems = items.map((item) => {

package/client/opcua-client-utils.js

@@ -102,9 +102,69 @@ function coerceValue(value, typeName) {
         case "UInt32":
             return Number.parseInt(value, 10);
 
-        case "Int64":
-        case "UInt64":
-            return BigInt(value);
+        case "Int64": {
+            const minVal = -9223372036854775808n;
+            const maxVal = 9223372036854775807n;
+            let bigintVal;
+            if (Array.isArray(value) && value.length === 2) {
+                const h = BigInt(value[0]);
+                const l = BigInt(value[1]);
+                const signMask = 1n << 31n;
+                const shiftHigh = 1n << 32n;
+                if ((h & signMask) === signMask) {
+                    bigintVal = (h & ~signMask) * shiftHigh + l - 0x8000000000000000n;
+                } else {
+                    bigintVal = h * shiftHigh + l;
+                }
+            } else {
+                try {
+                    bigintVal = BigInt(value);
+                } catch (e) {
+                    const parsed = Number(value);
+                    if (Number.isFinite(parsed)) {
+                        bigintVal = BigInt(Math.trunc(parsed));
+                    } else {
+                        bigintVal = 0n;
+                    }
+                }
+            }
+            if (bigintVal < minVal) bigintVal = minVal;
+            else if (bigintVal > maxVal) bigintVal = maxVal;
+
+            const mask = 0xFFFFFFFFFFFFFFFFn;
+            const unsignedVal = bigintVal & mask;
+            const high = Number(unsignedVal >> 32n);
+            const low = Number(unsignedVal & 0xFFFFFFFFn);
+            return [high, low];
+        }
+        case "UInt64": {
+            const minVal = 0n;
+            const maxVal = 18446744073709551615n;
+            let bigintVal;
+            if (Array.isArray(value) && value.length === 2) {
+                const h = BigInt(value[0]);
+                const l = BigInt(value[1]);
+                const shiftHigh = 1n << 32n;
+                bigintVal = h * shiftHigh + l;
+            } else {
+                try {
+                    bigintVal = BigInt(value);
+                } catch (e) {
+                    const parsed = Number(value);
+                    if (Number.isFinite(parsed)) {
+                        bigintVal = BigInt(Math.trunc(parsed));
+                    } else {
+                        bigintVal = 0n;
+                    }
+                }
+            }
+            if (bigintVal < minVal) bigintVal = minVal;
+            else if (bigintVal > maxVal) bigintVal = maxVal;
+
+            const high = Number(bigintVal >> 32n);
+            const low = Number(bigintVal & 0xFFFFFFFFn);
+            return [high, low];
+        }
 
         case "Float":
         case "Double":
@@ -218,12 +278,49 @@ function variantTypeToName(variant) {
     return DataType[variant.dataType] || String(variant.dataType);
 }
 
+function decode64BitValue(value, isUnsigned) {
+    if (Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+        const h = BigInt(value[0]);
+        const l = BigInt(value[1]);
+        const shiftHigh = 1n << 32n;
+        let bigintVal;
+        if (!isUnsigned) {
+            const signMask = 1n << 31n;
+            if ((h & signMask) === signMask) {
+                bigintVal = (h & ~signMask) * shiftHigh + l - 0x8000000000000000n;
+            } else {
+                bigintVal = h * shiftHigh + l;
+            }
+        } else {
+            bigintVal = h * shiftHigh + l;
+        }
+
+        const num = Number(bigintVal);
+        return num;
+    }
+    return value;
+}
+
+function resolve64BitValue(value, isUnsigned) {
+    if (Array.isArray(value)) {
+        if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+            return decode64BitValue(value, isUnsigned);
+        }
+        return value.map((val) => resolve64BitValue(val, isUnsigned));
+    }
+    return value;
+}
+
 function dataValueToItemResult(item, dataValue) {
     const variant = dataValue && dataValue.value ? dataValue.value : null;
+    let val = variant ? variant.value : null;
+    if (variant && (variant.dataType === DataType.Int64 || variant.dataType === DataType.UInt64)) {
+        val = resolve64BitValue(val, variant.dataType === DataType.UInt64);
+    }
     return {
         name: resolveName(item, resolveNodeId(item)),
         nodeID: resolveNodeId(item),
-        value: variant ? variant.value : null,
+        value: val,
         type: variantTypeToName(variant),
         status: statusCodeToString(dataValue && dataValue.statusCode),
         sourceTimestamp: timestampToIso(dataValue && dataValue.sourceTimestamp),
@@ -254,7 +351,8 @@ async function dataValueToItemResultEvent(item, eventFields, session) {
         active: eventFields[6]?.value?.text ?? null, // Active / Inactive
         AckedState: eventFields[7]?.value?.text ?? null, // Active / Inactive
         ConfirmedState: eventFields[8]?.value?.text ?? null,  // Active / Inactive
-        time: eventFields[9]?.value ?? null
+        time: eventFields[9]?.value ?? null,
+        conditionId: eventFields[10]?.value?.toString() ?? null
     };
 }
 
@@ -271,13 +369,19 @@ function callResultToItemResult(item, callResult, argumentDefinition) {
         name: resolveName(item, methodId),
         nodeID: methodId,
         status: statusCodeToString(callResult.statusCode),
-        outputs: outputArguments.map((variant, index) => ({
-            name: outputDefinitions[index] && outputDefinitions[index].name
-                ? String(outputDefinitions[index].name)
-                : "output" + (index + 1),
-            type: variantTypeToName(variant),
-            value: variant ? variant.value : null
-        }))
+        outputs: outputArguments.map((variant, index) => {
+            let val = variant ? variant.value : null;
+            if (variant && (variant.dataType === DataType.Int64 || variant.dataType === DataType.UInt64)) {
+                val = resolve64BitValue(val, variant.dataType === DataType.UInt64);
+            }
+            return {
+                name: outputDefinitions[index] && outputDefinitions[index].name
+                    ? String(outputDefinitions[index].name)
+                    : "output" + (index + 1),
+                type: variantTypeToName(variant),
+                value: val
+            };
+        })
     };
 }
 
@@ -364,6 +468,95 @@ async function getMethodArgumentDefinition(session, methodNodeId, cache) {
     return definition;
 }
 
+async function enrichItemResultWithEnumeration(result, session, cache, nodeId) {
+    if (result.type !== "Int32" && result.type !== "Enumeration") {
+        return result;
+    }
+    
+    if (typeof result.value !== "number" || !Number.isInteger(result.value)) {
+        return result;
+    }
+
+    try {
+        const cacheKeyType = "dt:" + nodeId;
+        let dtNodeId = cache ? cache.get(cacheKeyType) : undefined;
+        if (dtNodeId === undefined) {
+            const dv = await session.read({
+                nodeId: nodeId,
+                attributeId: AttributeIds.DataType
+            });
+            if (dv.statusCode.isGood()) {
+                dtNodeId = dv.value.value;
+                if (cache) cache.set(cacheKeyType, dtNodeId);
+            } else {
+                if (cache) cache.set(cacheKeyType, null);
+            }
+        }
+        
+        if (!dtNodeId) return result;
+        
+        const cacheKeyStrings = "enumStrings:" + dtNodeId.toString();
+        let enumStrings = cache ? cache.get(cacheKeyStrings) : undefined;
+        
+        if (enumStrings === undefined) {
+            const browseResult = await session.browse({
+                nodeId: dtNodeId,
+                referenceTypeId: "HasProperty",
+                browseDirection: BrowseDirection.Forward,
+                includeSubtypes: true,
+                resultMask: 63
+            });
+            
+            const enumStringsRef = browseResult.references ? browseResult.references.find(r => r.browseName.name === "EnumStrings") : null;
+            const enumValuesRef = browseResult.references ? browseResult.references.find(r => r.browseName.name === "EnumValues") : null;
+
+            if (enumStringsRef) {
+                const dataValue = await session.read({
+                    nodeId: enumStringsRef.nodeId,
+                    attributeId: AttributeIds.Value
+                });
+                if (dataValue.statusCode.isGood() && dataValue.value.value) {
+                    enumStrings = dataValue.value.value.map(lt => lt.text);
+                    if (cache) cache.set(cacheKeyStrings, enumStrings);
+                } else {
+                    if (cache) cache.set(cacheKeyStrings, null);
+                }
+            } else if (enumValuesRef) {
+                const dataValue = await session.read({
+                    nodeId: enumValuesRef.nodeId,
+                    attributeId: AttributeIds.Value
+                });
+                if (dataValue.statusCode.isGood() && dataValue.value.value) {
+                    const map = {};
+                    dataValue.value.value.forEach(ev => {
+                        let val;
+                        if (Array.isArray(ev.value) && ev.value.length === 2) {
+                            val = ev.value[1]; // low part of Int64
+                        } else {
+                            val = Number(ev.value);
+                        }
+                        map[val] = ev.displayName.text;
+                    });
+                    enumStrings = map;
+                    if (cache) cache.set(cacheKeyStrings, enumStrings);
+                } else {
+                    if (cache) cache.set(cacheKeyStrings, null);
+                }
+            } else {
+                if (cache) cache.set(cacheKeyStrings, null);
+            }
+        }
+        
+        if (enumStrings && enumStrings[result.value] !== undefined) {
+            result.valueEnumeration = enumStrings[result.value];
+        }
+    } catch (e) {
+        console.error("Error in enrichItemResultWithEnumeration:", e);
+    }
+    
+    return result;
+}
+
 module.exports = {
     AttributeIds,
     coerceNodeId,
@@ -374,6 +567,7 @@ module.exports = {
     callResultToItemResult,
     dataValueToItemResult,
     dataValueToItemResultEvent,
+    enrichItemResultWithEnumeration,
     ensureArrayPayload,
     getMethodArgumentDefinition,
     inferTypeName,