@vitormnm/node-red-simple-opcua 1.7.0 → 1.8.0

package/README.md

@@ -1,5 +1,3 @@
-# @vitormnm/node-red-simple-opcua
-
 OPC UA client and server with a simple graphical interface for Node-RED.
 
 This package provides a simplified, highly parameterized set of nodes to establish OPC UA Servers and Clients in Node-RED without complex coding.
@@ -40,6 +38,23 @@ Interacts with an active local server instance. It supports the following modes:
 
 ---
 
+### Supported Variable Data Types, Arrays & Matrices
+
+The server supports the following standard OPC UA data types, including arrays and matrices:
+
+- **Integers**: `Int16`, `UInt16`, `Int32`, `UInt32`, `Int64`
+- **Floats**: `Float`
+- **Others**: `Boolean`, `String`, `ByteString`
+- **Arrays (1D)**: Pass standard JavaScript arrays or JSON arrays as values (e.g., `[1, 2, 3, 4]` or `"[1, 2, 3, 4]"`).
+- **Multi-Dimensional Arrays (Matrices)**: Pass nested arrays. The dimensions are automatically detected based on the shape (e.g., `[[1, 2], [3, 4]]` is registered as a 2x2 matrix with dimensions `[2, 2]`, and `[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]` as a 2x2x2 matrix).
+
+*Note on 64-bit Integers (`Int64`/`UInt64`):*
+- *Scalars are represented as `[high, low]` arrays (e.g., `[0, 100]` for the value 100).*
+- *Arrays of 64-bit integers are represented as arrays of doublets (e.g., `[[0, 100], [0, 200]]`).*
+- *They are handled internally using JavaScript `BigInt`.*
+
+---
+
 ## Client Functionalities
 
 The client implementation consists of `opcua-client-config` (shared connection configuration) and `opcua-client` (the action node).

package/client/lib/opcua-client-browser.js

@@ -6,10 +6,11 @@ const {
     DataType,
     NodeClass,
     coerceNodeId,
-    makeNodeId
+    makeNodeId,
+    VariantArrayType
 } = require("node-opcua");
 
-const { enrichItemResultWithEnumeration } = require("../opcua-client-utils");
+const { enrichItemResultWithEnumeration, reshapeArray } = require("../opcua-client-utils");
 
 async function browseNode(session, root) {
     const nodeID = normalizeNodeId(root.nodeID || root.nodeId || ROOT_NODE_ID);
@@ -123,7 +124,14 @@ async function browseNode(session, root) {
         if (nodeClass === "Variable") {
             const dataTypeValue = dataValues[i * 3 + 1]?.value?.value;
             const rawValueVariant = dataValues[i * 3 + 2]?.value;
-            const rawValue = rawValueVariant?.value;
+            let rawValue = rawValueVariant?.value;
+
+            if (rawValueVariant && rawValueVariant.arrayType === VariantArrayType.Matrix && rawValueVariant.dimensions && (Array.isArray(rawValue) || ArrayBuffer.isView(rawValue))) {
+                if (ArrayBuffer.isView(rawValue)) {
+                    rawValue = Array.from(rawValue);
+                }
+                rawValue = reshapeArray(rawValue, rawValueVariant.dimensions);
+            }
 
             item.dataType = dataTypeValue?.namespace === 0 && typeof dataTypeValue?.value === "number"
                 ? (DataType[dataTypeValue.value] || dataTypeValue.toString())
@@ -525,7 +533,14 @@ async function browseRecursiveNode(session, root) {
                     if (item.nodeClass === "Variable") {
                         const dataTypeValue = dataValues[index * 3 + 1]?.value?.value;
                         const rawValueVariant = dataValues[index * 3 + 2]?.value;
-                        const rawValue = rawValueVariant?.value;
+                        let rawValue = rawValueVariant?.value;
+
+                        if (rawValueVariant && rawValueVariant.arrayType === VariantArrayType.Matrix && rawValueVariant.dimensions && (Array.isArray(rawValue) || ArrayBuffer.isView(rawValue))) {
+                            if (ArrayBuffer.isView(rawValue)) {
+                                rawValue = Array.from(rawValue);
+                            }
+                            rawValue = reshapeArray(rawValue, rawValueVariant.dimensions);
+                        }
 
                         item.dataType = dataTypeValue?.namespace === 0 && typeof dataTypeValue?.value === "number"
                             ? (DataType[dataTypeValue.value] || dataTypeValue.toString())

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

@@ -1,11 +1,12 @@
 "use strict";
 
-const { AttributeIds, DataType, coerceNodeId } = require("node-opcua");
+const { AttributeIds, DataType, coerceNodeId, VariantArrayType } = require("node-opcua");
 const {
     buildVariantFromItem,
     normalizeTypeName,
     resolveNodeId,
-    statusCodeToString
+    statusCodeToString,
+    reshapeArray
 } = require("../opcua-client-utils");
 
 // Máximo de tags por chamada session.write (ajuste conforme limite do servidor)
@@ -84,7 +85,7 @@ async function writeBatches(session, items, variants) {
                 allStatusCodes[start + i] = sc;
             });
         } catch (batchError) {
-            // Se o batch falhar por completo, marca todos com erro
+            
             for (let i = start; i < end; i++) {
                 allStatusCodes[i] = { name: batchError.message, value: -1 };
             }
@@ -109,10 +110,19 @@ function buildResults(items, variants, statusCodes) {
         const scName = sc && sc.name ? sc.name : "Good";
         const typeName = DataType[variants[index].dataType] || null;
 
+        let val = variants[index].value;
+        const variant = variants[index];
+        if (variant && variant.arrayType === VariantArrayType.Matrix && variant.dimensions && (Array.isArray(val) || ArrayBuffer.isView(val))) {
+            if (ArrayBuffer.isView(val)) {
+                val = Array.from(val);
+            }
+            val = reshapeArray(val, variant.dimensions);
+        }
+
         return {
             name: item.name || nodeId,
             nodeID: nodeId,
-            value: variants[index].value,
+            value: val,
             type: typeName,
             status: scName,
             sourceTimestamp: null,

package/client/opcua-client-config.js

@@ -8,7 +8,10 @@ const {
     getMethodArgumentDefinition,
     resolveMethodObjectId,
     resolveSecurityMode,
-    resolveSecurityPolicy
+    resolveSecurityPolicy,
+    AttributeIds,
+    dataValueToItemResult,
+    enrichItemResultWithEnumeration
 } = require("./opcua-client-utils");
 
 const {
@@ -214,6 +217,40 @@ module.exports = function (RED) {
             res.status(500).json({ error: error.message });
         }
     });
+
+    RED.httpAdmin.get("/opcua-client-config/:id/read", RED.auth.needsPermission("flows.read"), async function (req, res) {
+        try {
+            const configNode = RED.nodes.getNode(req.params.id);
+
+            if (!configNode) {
+                res.status(404).json({ error: "OPC UA client configuration not found" });
+                return;
+            }
+
+            const nodeId = req.query.nodeId;
+            if (!nodeId) {
+                throw new Error("Missing nodeId parameter");
+            }
+
+            const session = await configNode.getSession();
+            const dataValue = await session.read({
+                nodeId: nodeId,
+                attributeId: AttributeIds.Value
+            });
+
+            if (dataValue.statusCode && !dataValue.statusCode.isGood()) {
+                throw new Error("Read failed: " + dataValue.statusCode.toString());
+            }
+
+            const cache = new Map();
+            let result = dataValueToItemResult({ nodeID: nodeId }, dataValue);
+            result = await enrichItemResultWithEnumeration(result, session, cache, nodeId);
+
+            res.json({ value: result.value, valueEnumeration: result.valueEnumeration });
+        } catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
 };
 
 async function browseForEditor(configNode, nodeId) {

package/client/opcua-client-utils.js

@@ -204,6 +204,70 @@ function coerceValue(value, typeName) {
     }
 }
 
+function getArrayDimensions(value, typeName) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    // Check if it is a 64-bit scalar represented as [high, low]
+    if ((typeName === "Int64" || typeName === "UInt64") && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+        return null;
+    }
+
+    const hasNestedArray = value.some(item => {
+        if (Array.isArray(item)) {
+            if ((typeName === "Int64" || typeName === "UInt64") && item.length === 2 && typeof item[0] === "number" && typeof item[1] === "number") {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    });
+
+    if (!hasNestedArray) {
+        return null;
+    }
+
+    const dimensions = [];
+    let current = value;
+    while (Array.isArray(current)) {
+        if ((typeName === "Int64" || typeName === "UInt64") && current.length === 2 && typeof current[0] === "number" && typeof current[1] === "number") {
+            break;
+        }
+        dimensions.push(current.length);
+        if (current.length === 0) {
+            break;
+        }
+        current = current[0];
+    }
+    return dimensions;
+}
+
+function flattenMatrix(value, typeName) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    if ((typeName === "Int64" || typeName === "UInt64") && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+        return [value];
+    }
+
+    const flat = [];
+    const recurse = (a) => {
+        for (const item of a) {
+            if (Array.isArray(item)) {
+                if ((typeName === "Int64" || typeName === "UInt64") && item.length === 2 && typeof item[0] === "number" && typeof item[1] === "number") {
+                    flat.push(item);
+                } else {
+                    recurse(item);
+                }
+            } else {
+                flat.push(item);
+            }
+        }
+    };
+    recurse(value);
+    return flat;
+}
+
 function buildVariantFromItem(item, fallbackTypeName) {
     const typeName = normalizeTypeName(item.type || fallbackTypeName || inferTypeName(item.value));
     const dataType = DataType[typeName];
@@ -212,6 +276,23 @@ function buildVariantFromItem(item, fallbackTypeName) {
         throw new Error("Unsupported OPC UA data type: " + typeName);
     }
 
+    const dimensions = getArrayDimensions(item.value, typeName);
+    if (dimensions) {
+        // Multi-dimensional array (Matrix)
+        const flatVal = flattenMatrix(item.value, typeName);
+        const coercedArray = coerceValue(flatVal, typeName);
+        const TypedArrayCtor = TYPED_ARRAY_MAP[dataType];
+
+        return new Variant({
+            dataType,
+            arrayType: VariantArrayType.Matrix,
+            dimensions,
+            value: TypedArrayCtor
+                ? TypedArrayCtor.from(coercedArray)
+                : coercedArray
+        });
+    }
+
     const isArray = Array.isArray(item.value);
 
     if (isArray) {
@@ -311,12 +392,48 @@ function resolve64BitValue(value, isUnsigned) {
     return value;
 }
 
+function reshapeArray(flatArray, dimensions) {
+    if (!dimensions || dimensions.length <= 1) {
+        return flatArray;
+    }
+
+    const reshape = (arr, dims, offset) => {
+        const size = dims[0];
+        if (dims.length === 1) {
+            return {
+                result: arr.slice(offset, offset + size),
+                nextOffset: offset + size
+            };
+        }
+
+        const result = [];
+        let currentOffset = offset;
+        for (let i = 0; i < size; i++) {
+            const step = reshape(arr, dims.slice(1), currentOffset);
+            result.push(step.result);
+            currentOffset = step.nextOffset;
+        }
+        return {
+            result: result,
+            nextOffset: currentOffset
+        };
+    };
+
+    return reshape(flatArray, dimensions, 0).result;
+}
+
 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);
     }
+    if (variant && variant.arrayType === VariantArrayType.Matrix && variant.dimensions && (Array.isArray(val) || ArrayBuffer.isView(val))) {
+        if (ArrayBuffer.isView(val)) {
+            val = Array.from(val);
+        }
+        val = reshapeArray(val, variant.dimensions);
+    }
     return {
         name: resolveName(item, resolveNodeId(item)),
         nodeID: resolveNodeId(item),
@@ -374,6 +491,12 @@ function callResultToItemResult(item, callResult, argumentDefinition) {
             if (variant && (variant.dataType === DataType.Int64 || variant.dataType === DataType.UInt64)) {
                 val = resolve64BitValue(val, variant.dataType === DataType.UInt64);
             }
+            if (variant && variant.arrayType === VariantArrayType.Matrix && variant.dimensions && (Array.isArray(val) || ArrayBuffer.isView(val))) {
+                if (ArrayBuffer.isView(val)) {
+                    val = Array.from(val);
+                }
+                val = reshapeArray(val, variant.dimensions);
+            }
             return {
                 name: outputDefinitions[index] && outputDefinitions[index].name
                     ? String(outputDefinitions[index].name)
@@ -601,5 +724,6 @@ module.exports = {
     resolveNodeId,
     resolveSecurityMode,
     resolveSecurityPolicy,
+    reshapeArray,
     statusCodeToString
 };

package/client/opcua-client.html

@@ -50,6 +50,7 @@
         <div id="node-input-browse-context-menu" class="opcua-tree-context-menu" style="display:none;">
             <a href="#" id="node-input-browse-context-refresh"><i class="fa fa-refresh"></i> Refresh node</a>
             <a href="#" id="node-input-browse-context-copy-nodeid"><i class="fa fa-copy"></i> Copy NodeID</a>
+            <a href="#" id="node-input-browse-context-read-value"><i class="fa fa-eye"></i> Read value</a>
         </div>
     </div>
 

package/client/view/opcua-client.js

@@ -657,7 +657,7 @@
         }).fail(function (xhr) {
             var message = xhr && xhr.responseJSON && xhr.responseJSON.error
                 ? xhr.responseJSON.error
-                : "Falha ao navegar no servidor OPC UA.";
+                : "Failed to browse the OPC UA server.";
             browseState = null;
             container.html('<div class="opcua-tree-empty">' + escapeHtml(message) + '</div>');
             RED.notify(message, "error");
@@ -675,6 +675,7 @@
         contextMenuPath = path || "";
         $("#node-input-browse-context-refresh").toggle(!!item && !isVariable(item));
         $("#node-input-browse-context-copy-nodeid").toggle(!!nodeIdOf(item));
+        $("#node-input-browse-context-read-value").toggle(!!item && isVariable(item) && !!nodeIdOf(item));
         menu.css({ left: x + "px", top: y + "px" }).show();
     }
 
@@ -682,15 +683,15 @@
         var item = getItemAtPath(path);
         var nodeId = nodeIdOf(item);
         if (!nodeId) {
-            RED.notify("NodeID nao encontrado para o item selecionado.", "warning");
+            RED.notify("NodeID not found for the selected item.", "warning");
             return;
         }
 
         if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
             navigator.clipboard.writeText(nodeId).then(function () {
-                RED.notify("NodeID copiado.", "success");
+                RED.notify("NodeID copied.", "success");
             }).catch(function () {
-                RED.notify("Falha ao copiar NodeID.", "error");
+                RED.notify("Failed to copy NodeID.", "error");
             });
             return;
         }
@@ -704,13 +705,48 @@
         input[0].select();
         try {
             document.execCommand("copy");
-            RED.notify("NodeID copiado.", "success");
+            RED.notify("NodeID copied.", "success");
         } catch (error) {
-            RED.notify("Falha ao copiar NodeID.", "error");
+            RED.notify("Failed to copy NodeID.", "error");
         }
         input.remove();
     }
 
+    function readValueFromPath(path) {
+        var item = getItemAtPath(path);
+        var nodeId = nodeIdOf(item);
+        if (!nodeId) {
+            RED.notify("NodeID not found for the selected item.", "warning");
+            return;
+        }
+
+        var connectionId = $("#node-input-connection").val();
+        if (!connectionId) {
+            RED.notify("Select an OPC UA connection before reading.", "warning");
+            return;
+        }
+
+        $.getJSON("opcua-client-config/" + encodeURIComponent(connectionId) + "/read", {
+            nodeId: nodeId
+        }).done(function (payload) {
+            if (payload && payload.error) {
+                RED.notify("Read failed: " + payload.error, "error");
+            } else if (payload) {
+                var valueText = (payload.valueEnumeration !== undefined && payload.valueEnumeration !== null)
+                    ? payload.valueEnumeration + " (" + payload.value + ")"
+                    : (payload.value !== undefined ? String(payload.value) : "undefined");
+                RED.notify("Variable value: " + valueText, "success");
+            } else {
+                RED.notify("No value returned from the server.", "warning");
+            }
+        }).fail(function (xhr) {
+            var message = xhr && xhr.responseJSON && xhr.responseJSON.error
+                ? xhr.responseJSON.error
+                : "Failed to read variable value.";
+            RED.notify(message, "error");
+        });
+    }
+
     function setBrowseSelectedPath(path) {
         browseSelectedPath = path || "";
         $(".opcua-tree-row").removeClass("is-selected");
@@ -759,20 +795,51 @@
         renderBrowseTree();
         var browseNodeId = item.nodeID || item.nodeId;
         loadBrowse(browseNodeId).done(function (payload) {
-
-            
-
-            item.browse = Array.isArray(payload.browse) ? payload.browse : [];
-            saveBrowseSession();
-            renderBrowseTree();
+            try {
+                if (!payload) {
+                    console.error("Browse returned empty payload for node " + browseNodeId);
+                    RED.notify("Browse returned empty payload.", "error");
+                    item.browse = [];
+                } else if (payload.error) {
+                    console.error("Browse returned error for node " + browseNodeId + ":", payload.error);
+                    RED.notify(payload.error, "error");
+                    item.browse = [];
+                } else {
+                    item.browse = Array.isArray(payload.browse) ? payload.browse : [];
+                }
+                saveBrowseSession();
+                renderBrowseTree();
+                triggerChildrenExpansion(item.browse, path);
+            } catch (err) {
+                console.error("Error handling browse payload for node " + browseNodeId + ":", err);
+                RED.notify("Error handling browse response: " + err.message, "error");
+                expansionState[path] = false;
+                saveBrowseSession();
+                renderBrowseTree();
+            }
         }).fail(function (xhr) {
             expansionState[path] = false;
             saveBrowseSession();
             renderBrowseTree();
             var message = xhr && xhr.responseJSON && xhr.responseJSON.error
                 ? xhr.responseJSON.error
-                : "Falha ao expandir o node.";
+                : "Failed to expand the node.";
             RED.notify(message, "error");
+            console.error("Browse request failed for node " + browseNodeId + ":", xhr);
+        });
+    }
+
+    function triggerChildrenExpansion(children, parentPath) {
+        if (!Array.isArray(children)) return;
+        children.forEach(function (child, index) {
+            var childPath = parentPath + ".browse." + index;
+            if (isExpanded(childPath, false)) {
+                if (!Array.isArray(child.browse)) {
+                    expandNode(childPath);
+                } else {
+                    triggerChildrenExpansion(child.browse, childPath);
+                }
+            }
         });
     }
 
@@ -1057,7 +1124,24 @@
         if ($(event.target).closest(".opcua-client-toggle-tree, .opcua-client-toggle-tag, .opcua-tree-actions, #node-input-browse-context-menu").length) {
             return;
         }
-        setBrowseSelectedPath($(this).attr("data-path"));
+        var path = $(this).attr("data-path");
+        setBrowseSelectedPath(path);
+
+        if (event.ctrlKey || event.metaKey) {
+            event.preventDefault();
+            if ($("#node-input-mode").val() === "method") {
+                var item = getItemAtPath(path);
+                if (item && item.nodeClass === "Method") {
+                    var parentPath = path.split(".");
+                    parentPath.splice(parentPath.length - 2, 2);
+                    parentPath = parentPath.join(".");
+                    var parentItem = getItemAtPath(parentPath);
+                    addMethodFromTree(item, parentItem);
+                    return;
+                }
+            }
+            toggleSelectedNode(path);
+        }
     });
 
     $(document).on("contextmenu", ".opcua-tree-row", function (event) {
@@ -1091,6 +1175,14 @@
         copyNodeIdFromPath(path);
     });
 
+    $(document).on("click", "#node-input-browse-context-read-value", function (event) {
+        event.preventDefault();
+        var highlightedPath = $(".opcua-tree-row.is-selected").first().attr("data-path") || "";
+        var path = contextMenuPath || browseSelectedPath || highlightedPath || "";
+        hideTreeContextMenu();
+        readValueFromPath(path);
+    });
+
     $(document).on("click", function (event) {
         if (!$(event.target).closest("#node-input-browse-context-menu").length) {
             hideTreeContextMenu();

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@vitormnm/node-red-simple-opcua",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "publishConfig": {
     "access": "public"
   },
-  "description": "Custom Node-RED OPC UA server and client node powered by node-opcua",
+  "description": "OPC UA server and client nodes with a graphical interface, powered by node-opcua",
   "main": "server/opcua-server.js",
   "node-red": {
     "version": ">=3.0.0",