loupedeck-commander 1.4.0 → 1.4.2

package/interfaces/opcuaif.mjs

@@ -1,481 +1,484 @@
-import {
-    OPCUAClient,
-    MessageSecurityMode,
-    SecurityPolicy,
-    AttributeIds,
-    resolveNodeId,
-    TimestampsToReturn,
-    DataType
-} from "node-opcua";
-
-import { BaseIf } from './baseif.mjs'
-
-/**
- * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
- */
-export class OPCUAIf extends BaseIf {
-
-    #client
-    #session
-    #sub
-    #connected
-    #endpointurl
-    #publishingInterval
-    #samplingInterval
-    // Dictionary to store monitored items : key = monitoredItemId, value = nodeID
-    monitoreditems
-    types
-    // Dictionary to store buttons : key = monitoredItemId, value = buttonID
-    buttons
-    constructor() {
-        super()
-    }
-
-    /**
-     * Initialize the OPCUA client and subscribe to monitored items.
-     * @param {*} options 
-     * @param {*} config 
-     * @param {*} callbackFunction 
-     */
-    async init(options = {}, config = {}) {
-        var res = this.Check(options)
-        if (res < 0) {
-            this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options\n`)
-        }
-        try {
-            this.#endpointurl = this.formatString(options.endpointurl, options)
-            if (options.publishingInterval)
-                this.#publishingInterval = options.publishingInterval
-            else {
-                this.#publishingInterval = 250;
-                this.LogInfo(`OPCUAIf init using default publishingInterval: ${this.#publishingInterval}ms\n`);
-            }
-            if (options.samplingInterval)
-                this.#samplingInterval = options.samplingInterval
-            else {
-                this.#samplingInterval = 100;
-                this.LogInfo(`OPCUAIf init using default samplingInterval: ${this.#samplingInterval}ms\n`);
-            }
-            this.options = options
-            this.monitoreditems = {}
-            this.types = {}
-            this.buttons = {}
-            this.LogInfo(`OPCUAIf init ${this.#endpointurl}\n`);
-
-            await this.Connect(this.#endpointurl);
-
-            let fields = [config.touch.center, config.knobs, config.buttons]
-            for (let f = 0; f < fields.length; f++) {
-                let field = fields[f]
-                const buttonNames = Object.keys(field)
-
-                // Iterate over buttons:
-                for (let i = 0; i < buttonNames.length; i++) {
-                    const buttonID = buttonNames[i]
-                    const elem = field[buttonID]
-                    options["key"] = buttonID        // we have to know the key of the button
-                    // groupnode
-                    if (elem.params) {
-                        let attributes = ["nodeid", "blink"]
-                        for (let j = 0; j < attributes.length; j++) {
-                            const attribute = attributes[j]
-                            let nodeID = super.formatString(elem.params[attribute], options)
-                            if (attribute in elem.params) {
-                                if (!this.IsNodeID(nodeID)) {
-                                    continue
-                                }
-
-                                let monitoredItemId = await this.Subscribe(nodeID, options,attribute)
-                                if (monitoredItemId) {
-                                    console.log("Register nodeid",nodeID, monitoredItemId, buttonID, attribute,)
-                                    if (this.buttons[monitoredItemId] == undefined)
-                                        this.buttons[monitoredItemId] = []
-                                    this.buttons[monitoredItemId].push({
-                                        buttonID: i,
-                                        buttonName: buttonID,
-                                        attribute: attribute
-                                    })
-                                }
-                            }
-                        }
-                    }
-                    if (elem.states) {
-                        let attributes = ["opcua", "blink"]
-                        let states = Object.values(elem.states)
-                        // Iterate over states:
-                        for (let j = 0; j < states.length; j++) {
-                            const state = states[j]
-
-                            for (let k = 0; k < attributes.length; k++) {
-                                const attribute = attributes[k]
-                                let nodeID = super.formatString(state[attribute], options)
-                                if (attribute in state) {
-                                    if (!this.IsNodeID(nodeID)) {
-                                        continue
-                                    }      
-                                    let monitoredItemId = await this.Subscribe(nodeID, options,attribute)
-                                    if (monitoredItemId) {
-                                        console.log("Register state",monitoredItemId, buttonID, attribute,nodeID)
-                                        if (this.buttons[monitoredItemId] == undefined)
-                                            this.buttons[monitoredItemId] = []
-                                        this.buttons[monitoredItemId].push({
-                                            buttonID: i,
-                                            buttonName: buttonID,
-                                            attribute: attribute
-                                        })
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        } catch (error) {
-            this.LogError(`OPCUAIf: Error\n`, error)
-        }
-    }
-
-    /**
-     * Convert the given value to the specified type.
-     * @param {*} value : The value to convert.
-     * @param {*} type : The type to convert to. Can be one of the following:
-     * - DataType.Int16
-     * - DataType.Int32
-     * - DataType.Float
-     * - DataType.String
-     * @returns the converted value.
-     */
-    convert(value, type) {
-        switch (type) {
-            case DataType.Int16:
-            case DataType.Int32:
-                if (typeof value == "number") {
-                    if (Number.isInteger(value))
-                        return value
-                    else
-                        return Math.trunc(value)
-                }
-                return parseInt(value, 10)
-                break
-            case DataType.Float:
-                if (typeof value == "number")
-                    return value
-                return parseFloat(value)
-                break;
-            case DataType.String:
-                if (typeof value == "number")
-                    return value.toString();
-                return value
-            case DataType.Boolean:
-                if (typeof value == "number" && value === 1)
-                    return true
-                if (typeof value == "string") {
-                    if (["true", "on"].includes(value)) {
-                        return true
-                    }
-                }
-                return false
-            default:
-                return value
-        }
-    }
-
-    /**
-     * Call the OPCUA node with the given options.
-     * This method will write the value to the node and return the new state.
-     * @param {*} opcuaNode 
-     * @param {*} options 
-     * @returns 
-     */
-    async call(opcuaNode, options = {}) {
-        var res = this.Check(options)
-        if (res < 0) {
-            //            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res\n`)
-            return false
-        }
-
-        var nodeId = super.call(opcuaNode, options)
-
-        var type = this.types[nodeId]
-        
-        if (type === undefined){
-            let dataValue = await this.Read(nodeId)
-            this.types[nodeId]  = dataValue.value.dataType
-            type = this.types[nodeId]
-        }
-        var value = options.value
-        if (typeof value == "string")
-            value = super.formatString(options.value, options)
-
-        var convertedValue = this.convert(value, type)
-        this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}\n`)
-        await this.Write(nodeId, convertedValue, type)
-
-        var NewState = "waiting"
-        return NewState
-    }
-
-    Check(options) {
-        var res = super.Check(options)
-        if (res < 0) {
-            this.LogError(`OPCUAIf: mandatory parameter missing\n`)
-            return res
-        }
-        if (!"endpointurl" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter endpointurl missing\n`)
-            return -11
-        }
-        if (!"publishingInterval" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter publishingInterval missing\n`)
-            return -11
-        }
-        if (!"nodeid" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter nodeid missing\n`)
-            return -12
-        }
-        if (!"value" in options) {
-            this.LogError(`OPCUAIf: mandatory parameter value missing\n`)
-            return -13
-        }
-        return 0
-    }
-
-    /**
-     * This method is called when the interface is stopped.
-     * It will disconnect the client and stop the subscription.
-     * @returns 
-     */
-    async stop() {
-        if (!this.#client)
-            return
-        await this.Disconnect()
-        this.LogInfo(`OPCUAIf Stopped\n`)
-    }
-
-    /**
-     * Disconnect the OPCUA client and close the session.
-     */
-    async Disconnect() {
-        if (this.#client) {
-            if (this.#session)
-                await this.#client.closeSession(this.#session, true)
-            this.#session = undefined
-            this.#client = undefined
-            this.LogInfo(`OPCUAIf: Disconnected\n`);
-        }
-    }
-    /**
-     * Connect to the OPCUA server with the given URL.
-     * @param {string} url - The URL of the OPCUA server, typical format: opc.tcp://ip-address:4840 .
-     */
-    async Connect(url) {
-        let self = this
-        if (this.#client) {
-            await this.Disconnect()
-        }
-
-        this.#client = OPCUAClient.create({
-            applicationName: "NodeOPCUA-Client",
-            endpointMustExist: true,
-            // keepSessionAlive: true,
-            requestedSessionTimeout: 60 * 1000,
-            securityMode: MessageSecurityMode.None,
-            securityPolicy: SecurityPolicy.None,
-            connectionStrategy: {
-                maxRetry: -1,
-                maxDelay: 5000,
-                initialDelay: 2500
-            },
-
-            defaultSecureTokenLifetime: 20000,
-            tokenRenewalInterval: 1000
-        });
-
-
-        this.#client.on("backoff", (retry, delay) => {
-            //if ((retry % 10) == 0)
-            //    self.LogInfo(`OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}\n`);
-        });
-
-        this.#client.on("connection_lost", () => {
-            self.LogInfo(`OPCUAIf: Connection lost\n`);
-        });
-
-        this.#client.on("connection_reestablished", () => {
-            self.LogInfo(`OPCUAIf: Connection re-established\n`);
-        });
-
-        this.#client.on("connection_failed", () => {
-            self.LogInfo(`OPCUAIf: Connection failed\n`);
-        });
-        this.#client.on("start_reconnection", () => {
-            self.LogInfo(`OPCUAIf: Starting reconnection\n`);
-        });
-
-        this.#client.on("after_reconnection", (err) => {
-            self.LogInfo(`OPCUAIf: After Reconnection event => ${err}\n`);
-        });
-        /*this.#client.on("security_token_renewed", () => {
-            self.LogDebug(`OPCUAIf: security_token_renewed\n`);
-        })*/
-        this.#client.on("lifetime_75", (token) => { })
-
-        this.LogInfo(`OPCUAIf: connecting client to ${url}\n`);//, this.#session.toString());
-        await this.#client.connect(url);
-
-        this.#session = await this.#client.createSession();
-
-        this.#session.on("session_closed", (statusCode) => {
-            //self.LogInfo(`OPCUAIf: Session has been closed\n`);
-        })
-        this.#session.on("session_restored", () => {
-            //self.LogInfo(`OPCUAIf: Session has been restored\n`);
-        });
-        this.#session.on("keepalive", (lastKnownServerState) => {
-            self.LogInfo(`OPCUAIf: KeepAlive lastKnownServerState ${lastKnownServerState}\n`);
-        });
-        this.#session.on("keepalive_failure", () => {
-            self.LogInfo(`OPCUAIf: KeepAlive failure\n`);
-        });
-
-        // create subscription with a custom publishing interval:
-        this.#sub = await this.#session.createSubscription2({
-            maxNotificationsPerPublish: 9000,
-            publishingEnabled: true,
-            requestedLifetimeCount: 10,
-            requestedMaxKeepAliveCount: 10,
-            requestedPublishingInterval: this.#publishingInterval
-        });
-
-        this.LogInfo(`OPCUAIf: session created\n`);
-        //        this.LogInfo(`OPCUAIf: client\n`);
-        //        this.LogInfo(`OPCUAIf: subscription\n`);
-        this.#connected = true
-        this.#endpointurl = url
-    }
-
-    /**
-     * Check if the given nodeID is a valid OPCUA nodeID.
-     * A valid nodeID has the format: ns=<namespace index>;s=<identifier>
-     * where <namespace index> is a number and <identifier> is a string.
-     * @param {*} nodeID 
-     * @returns 
-     */
-    IsNodeID(nodeID) {
-        let strNodeID = nodeID.toString()
-        // regex: ns=\d;s=.*
-        if (strNodeID.match(/^ns=\d+;s=.*$/)) {
-            return true
-        }
-        return false
-    }
-
-    /**
-     * Register a subscription for a nodeID.
-     * This method will create a monitored item for the given nodeID and return the monitored item ID.
-     * If the nodeID is already registered, it will return the existing monitored item ID.
-     * @param {*} nodeID 
-     * @returns 
-     */
-    async Subscribe(unformattedNodeID, options = {},attribute) {
-        // Format the nodeID using the provided options
-        let nodeID = this.formatString(unformattedNodeID, options)
-        
-        // install monitored item
-        const monitoredNodeIdList = Object.keys(this.monitoreditems)
-        let monitorItemId = -1
-        for (let i = 0; i < monitoredNodeIdList.length; i++) {
-            let monitorItemId = monitoredNodeIdList[i]
-            if (this.monitoreditems[monitorItemId] == nodeID) {
-                return monitorItemId                  // already registered => return itemid
-            }
-        }
-
-        const itemToMonitor = {
-            nodeId: resolveNodeId(nodeID),
-            attributeId: AttributeIds.Value
-        };
-        const monitoringParameters = {
-            samplingInterval: this.#samplingInterval,
-            discardOldest: true,
-            queueSize: 10
-        };
-
-        if (!this.#sub) {
-            this.LogError(`OPCUAIf: no subscription - don't register monitored items $itemToMonitor\n`);
-            return
-        }
-        const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
-        this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
-        if (monitoredItem.monitoredItemId === undefined) {
-            this.LogError(`OPCUAIf: Error subscribing to node ${nodeID} (attribute ${attribute})\n`)
-        } else {
-            this.LogDebug(`OPCUAIf: Subscribe to ${monitoredItem.monitoredItemId},${nodeID},(attribute ${attribute})\n`);
-        }
-
-        var self = this
-        monitoredItem.on("changed", function (dataValue) {
-            var nodeId = self.monitoreditems[this.monitoredItemId]
-            
-            // store the type of a nodeid in local dictionary
-            self.types[nodeId] = dataValue.value.dataType
-            // publish the value to subscribers:
-            let buttons = self.buttons[this.monitoredItemId]
-            for (var i=0;i<buttons.length;i++){
-                var buttonInfo = buttons[i]
-                self.LogInfo(`OPCUAIf: monitored item changed: ${buttonInfo.buttonID} ${buttonInfo.attribute} ${nodeId} => ${dataValue.value.value}\n`);
-                self.emit('monitored item changed', buttonInfo.buttonID, buttonInfo.attribute, nodeId, dataValue.value.value)
-            }
-        });
-
-        return monitoredItem.monitoredItemId;
-    }
-
-    async Read(nodeID) {
-        const nodeToRead = {
-            nodeId: nodeID,
-            attributeId: AttributeIds.Value
-        };
-        if (!this.#connected) {
-            this.LogError(`OPCUAIf: not connected, cannot read ${nodeID}\n`);
-            return
-        }
-        const dataValue2 = await this.#session.read(nodeToRead, 0);
-        this.LogError("OPCUAIf: read nodeID ", nodeID, dataValue2.toString(), "\n");
-        return dataValue2
-    }
-
-    async Write(nodeID, value, datatype = DataType.String) {
-        let self = this
-        if (!this.#connected) {
-            self.LogError("OPCUAIf: not connected, cannot write", nodeID, value, "\n");
-            return
-        }
-        var nodesToWrite = [{
-            nodeId: nodeID,
-            attributeId: AttributeIds.Value,
-            indexRange: null,
-            value: {
-                value: {
-                    dataType: datatype,
-                    value: value
-                }
-            }
-        }];
-        try {
-            await this.#session.write(nodesToWrite, function (err, statusCodes) {
-                if (!err) {
-                    if (statusCodes && statusCodes[0].value != 0) {
-                        self.LogInfo(`OPCUAIf: error with Node: "${nodeID}", status ${statusCodes[0]}\n`);
-                    } else {
-                        self.LogInfo(`OPCUAIf: wrote ${nodeID} => ${value}\n`);
-                    }
-                } else {
-                    self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}\n`);
-                }
-            });
-        } catch (err) {
-            self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}\n`);
-        }
-    }
-}
+import {
+    OPCUAClient,
+    MessageSecurityMode,
+    SecurityPolicy,
+    AttributeIds,
+    resolveNodeId,
+    TimestampsToReturn,
+    DataType
+} from "node-opcua";
+
+import { BaseIf } from './baseif.mjs'
+
+/**
+ * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class OPCUAIf extends BaseIf {
+
+    #client
+    #session
+    #sub
+    #connected
+    #endpointurl
+    #publishingInterval
+    #samplingInterval
+    // Dictionary to store monitored items : key = monitoredItemId, value = nodeID
+    monitoreditems
+    types
+    // Dictionary to store buttons : key = monitoredItemId, value = buttonID
+    buttons
+    constructor() {
+        super()
+    }
+
+    /**
+     * Initialize the OPCUA client and subscribe to monitored items.
+     * @param {*} options 
+     * @param {*} config 
+     * @param {*} callbackFunction 
+     */
+    async init(options = {}, config = {}) {
+        var res = this.Check(options)
+        if (res < 0) {
+            this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options\n`)
+        }
+        try {
+            this.#endpointurl = this.formatString(options.endpointurl, options)
+            if (options.publishingInterval)
+                this.#publishingInterval = options.publishingInterval
+            else {
+                this.#publishingInterval = 250;
+                this.LogInfo(`OPCUAIf init using default publishingInterval: ${this.#publishingInterval}ms\n`);
+            }
+            if (options.samplingInterval)
+                this.#samplingInterval = options.samplingInterval
+            else {
+                this.#samplingInterval = 100;
+                this.LogInfo(`OPCUAIf init using default samplingInterval: ${this.#samplingInterval}ms\n`);
+            }
+            this.options = options
+            this.monitoreditems = {}
+            this.types = {}
+            this.buttons = {}
+            this.LogInfo(`OPCUAIf init ${this.#endpointurl}\n`);
+
+            await this.Connect(this.#endpointurl);
+
+            let fields = [config.touch.center, config.knobs, config.buttons]
+            for (let f = 0; f < fields.length; f++) {
+                let field = fields[f]
+                const buttonNames = Object.keys(field)
+
+                // Iterate over buttons:
+                for (let i = 0; i < buttonNames.length; i++) {
+                    const buttonID = buttonNames[i]
+                    const elem = field[buttonID]
+                    options["key"] = buttonID        // we have to know the key of the button
+                    // groupnode
+                    if (elem.params) {
+                        let attributes = ["nodeid", "blink"]
+                        for (let j = 0; j < attributes.length; j++) {
+                            const attribute = attributes[j]
+                            let nodeID = super.formatString(elem.params[attribute], options)
+                            if (attribute in elem.params) {
+                                if (!this.IsNodeID(nodeID)) {
+                                    continue
+                                }
+
+                                let monitoredItemId = await this.Subscribe(nodeID, options, attribute)
+                                if (monitoredItemId) {
+                                    console.log("Register nodeid", nodeID, monitoredItemId, buttonID, attribute,)
+                                    if (this.buttons[monitoredItemId] == undefined)
+                                        this.buttons[monitoredItemId] = []
+                                    this.buttons[monitoredItemId].push({
+                                        buttonID: i,
+                                        buttonName: buttonID,
+                                        attribute: attribute
+                                    })
+                                }
+                            }
+                        }
+                    }
+                    if (elem.states) {
+                        let attributes = ["opcua", "blink"]
+                        let states = Object.values(elem.states)
+                        // Iterate over states:
+                        for (let j = 0; j < states.length; j++) {
+                            const state = states[j]
+
+                            for (let k = 0; k < attributes.length; k++) {
+                                const attribute = attributes[k]
+                                let nodeID = super.formatString(state[attribute], options)
+                                if (attribute in state) {
+                                    if (!this.IsNodeID(nodeID)) {
+                                        continue
+                                    }
+                                    let monitoredItemId = await this.Subscribe(nodeID, options, attribute)
+                                    if (monitoredItemId) {
+                                        console.log("Register state", monitoredItemId, buttonID, attribute, nodeID)
+                                        if (this.buttons[monitoredItemId] == undefined)
+                                            this.buttons[monitoredItemId] = []
+                                        this.buttons[monitoredItemId].push({
+                                            buttonID: i,
+                                            buttonName: buttonID,
+                                            attribute: attribute
+                                        })
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            this.LogError(`OPCUAIf: Error\n`, error)
+        }
+    }
+
+    /**
+     * Convert the given value to the specified type.
+     * @param {*} value : The value to convert.
+     * @param {*} type : The type to convert to. Can be one of the following:
+     * - DataType.Int16
+     * - DataType.Int32
+     * - DataType.Float
+     * - DataType.String
+     * @returns the converted value.
+     */
+    convert(value, type) {
+        switch (type) {
+            case DataType.Int16:
+            case DataType.Int32:
+                if (typeof value == "number") {
+                    if (Number.isInteger(value))
+                        return value
+                    else
+                        return Math.trunc(value)
+                }
+                return parseInt(value, 10)
+                break
+            case DataType.Float:
+                if (typeof value == "number")
+                    return value
+                return parseFloat(value)
+                break;
+            case DataType.String:
+                if (typeof value == "number")
+                    return value.toString();
+                return value
+            case DataType.Boolean:
+                if (typeof value == "number" && value === 1)
+                    return true
+                if (typeof value == "string") {
+                    if (["true", "on"].includes(value)) {
+                        return true
+                    }
+                }
+                return false
+            default:
+                return value
+        }
+    }
+
+    /**
+     * Call the OPCUA node with the given options.
+     * This method will write the value to the node and return the new state.
+     * @param {*} opcuaNode 
+     * @param {*} options 
+     * @returns 
+     */
+    async call(opcuaNode, options = {}) {
+        var res = this.Check(options)
+        if (res < 0) {
+            //            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res\n`)
+            return false
+        }
+
+        var nodeId = super.call(opcuaNode, options)
+
+        var type = this.types[nodeId]
+
+        if (type === undefined) {
+            let dataValue = await this.Read(nodeId)
+            if (dataValue) {
+                this.types[nodeId] = dataValue.value.dataType
+                type = this.types[nodeId]
+            }
+
+        }
+        var value = options.value
+        if (typeof value == "string")
+            value = super.formatString(options.value, options)
+
+        var convertedValue = this.convert(value, type)
+        this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}\n`)
+        await this.Write(nodeId, convertedValue, type)
+
+        var NewState = "waiting"
+        return NewState
+    }
+
+    Check(options) {
+        var res = super.Check(options)
+        if (res < 0) {
+            this.LogError(`OPCUAIf: mandatory parameter missing\n`)
+            return res
+        }
+        if (!"endpointurl" in options) {
+            this.LogError(`OPCUAIf: mandatory parameter endpointurl missing\n`)
+            return -11
+        }
+        if (!"publishingInterval" in options) {
+            this.LogError(`OPCUAIf: mandatory parameter publishingInterval missing\n`)
+            return -11
+        }
+        if (!"nodeid" in options) {
+            this.LogError(`OPCUAIf: mandatory parameter nodeid missing\n`)
+            return -12
+        }
+        if (!"value" in options) {
+            this.LogError(`OPCUAIf: mandatory parameter value missing\n`)
+            return -13
+        }
+        return 0
+    }
+
+    /**
+     * This method is called when the interface is stopped.
+     * It will disconnect the client and stop the subscription.
+     * @returns 
+     */
+    async stop() {
+        if (!this.#client)
+            return
+        await this.Disconnect()
+        this.LogInfo(`OPCUAIf Stopped\n`)
+    }
+
+    /**
+     * Disconnect the OPCUA client and close the session.
+     */
+    async Disconnect() {
+        if (this.#client) {
+            if (this.#session)
+                await this.#client.closeSession(this.#session, true)
+            this.#session = undefined
+            this.#client = undefined
+            this.LogInfo(`OPCUAIf: Disconnected\n`);
+        }
+    }
+    /**
+     * Connect to the OPCUA server with the given URL.
+     * @param {string} url - The URL of the OPCUA server, typical format: opc.tcp://ip-address:4840 .
+     */
+    async Connect(url) {
+        let self = this
+        if (this.#client) {
+            await this.Disconnect()
+        }
+
+        this.#client = OPCUAClient.create({
+            applicationName: "NodeOPCUA-Client",
+            endpointMustExist: true,
+            // keepSessionAlive: true,
+            requestedSessionTimeout: 60 * 1000,
+            securityMode: MessageSecurityMode.None,
+            securityPolicy: SecurityPolicy.None,
+            connectionStrategy: {
+                maxRetry: -1,
+                maxDelay: 5000,
+                initialDelay: 2500
+            },
+
+            defaultSecureTokenLifetime: 20000,
+            tokenRenewalInterval: 1000
+        });
+
+
+        this.#client.on("backoff", (retry, delay) => {
+            //if ((retry % 10) == 0)
+            //    self.LogInfo(`OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}\n`);
+        });
+
+        this.#client.on("connection_lost", () => {
+            self.LogInfo(`OPCUAIf: Connection lost\n`);
+        });
+
+        this.#client.on("connection_reestablished", () => {
+            self.LogInfo(`OPCUAIf: Connection re-established\n`);
+        });
+
+        this.#client.on("connection_failed", () => {
+            self.LogInfo(`OPCUAIf: Connection failed\n`);
+        });
+        this.#client.on("start_reconnection", () => {
+            self.LogInfo(`OPCUAIf: Starting reconnection\n`);
+        });
+
+        this.#client.on("after_reconnection", (err) => {
+            self.LogInfo(`OPCUAIf: After Reconnection event => ${err}\n`);
+        });
+        /*this.#client.on("security_token_renewed", () => {
+            self.LogDebug(`OPCUAIf: security_token_renewed\n`);
+        })*/
+        this.#client.on("lifetime_75", (token) => { })
+
+        this.LogInfo(`OPCUAIf: connecting client to ${url}\n`);//, this.#session.toString());
+        await this.#client.connect(url);
+
+        this.#session = await this.#client.createSession();
+
+        this.#session.on("session_closed", (statusCode) => {
+            //self.LogInfo(`OPCUAIf: Session has been closed\n`);
+        })
+        this.#session.on("session_restored", () => {
+            //self.LogInfo(`OPCUAIf: Session has been restored\n`);
+        });
+        this.#session.on("keepalive", (lastKnownServerState) => {
+            self.LogInfo(`OPCUAIf: KeepAlive lastKnownServerState ${lastKnownServerState}\n`);
+        });
+        this.#session.on("keepalive_failure", () => {
+            self.LogInfo(`OPCUAIf: KeepAlive failure\n`);
+        });
+
+        // create subscription with a custom publishing interval:
+        this.#sub = await this.#session.createSubscription2({
+            maxNotificationsPerPublish: 9000,
+            publishingEnabled: true,
+            requestedLifetimeCount: 10,
+            requestedMaxKeepAliveCount: 10,
+            requestedPublishingInterval: this.#publishingInterval
+        });
+
+        this.LogInfo(`OPCUAIf: session created\n`);
+        //        this.LogInfo(`OPCUAIf: client\n`);
+        //        this.LogInfo(`OPCUAIf: subscription\n`);
+        this.#connected = true
+        this.#endpointurl = url
+    }
+
+    /**
+     * Check if the given nodeID is a valid OPCUA nodeID.
+     * A valid nodeID has the format: ns=<namespace index>;s=<identifier>
+     * where <namespace index> is a number and <identifier> is a string.
+     * @param {*} nodeID 
+     * @returns 
+     */
+    IsNodeID(nodeID) {
+        let strNodeID = nodeID.toString()
+        // regex: ns=\d;s=.*
+        if (strNodeID.match(/^ns=\d+;s=.*$/)) {
+            return true
+        }
+        return false
+    }
+
+    /**
+     * Register a subscription for a nodeID.
+     * This method will create a monitored item for the given nodeID and return the monitored item ID.
+     * If the nodeID is already registered, it will return the existing monitored item ID.
+     * @param {*} nodeID 
+     * @returns 
+     */
+    async Subscribe(unformattedNodeID, options = {}, attribute) {
+        // Format the nodeID using the provided options
+        let nodeID = this.formatString(unformattedNodeID, options)
+
+        // install monitored item
+        const monitoredNodeIdList = Object.keys(this.monitoreditems)
+        let monitorItemId = -1
+        for (let i = 0; i < monitoredNodeIdList.length; i++) {
+            let monitorItemId = monitoredNodeIdList[i]
+            if (this.monitoreditems[monitorItemId] == nodeID) {
+                return monitorItemId                  // already registered => return itemid
+            }
+        }
+
+        const itemToMonitor = {
+            nodeId: resolveNodeId(nodeID),
+            attributeId: AttributeIds.Value
+        };
+        const monitoringParameters = {
+            samplingInterval: this.#samplingInterval,
+            discardOldest: true,
+            queueSize: 10
+        };
+
+        if (!this.#sub) {
+            this.LogError(`OPCUAIf: no subscription - don't register monitored items $itemToMonitor\n`);
+            return
+        }
+        const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
+        this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
+        if (monitoredItem.monitoredItemId === undefined) {
+            this.LogError(`OPCUAIf: Error subscribing to node ${nodeID} (attribute ${attribute})\n`)
+        } else {
+            this.LogDebug(`OPCUAIf: Subscribe to ${monitoredItem.monitoredItemId},${nodeID},(attribute ${attribute})\n`);
+        }
+
+        var self = this
+        monitoredItem.on("changed", function (dataValue) {
+            var nodeId = self.monitoreditems[this.monitoredItemId]
+
+            // store the type of a nodeid in local dictionary
+            self.types[nodeId] = dataValue.value.dataType
+            // publish the value to subscribers:
+            let buttons = self.buttons[this.monitoredItemId]
+            for (var i = 0; i < buttons.length; i++) {
+                var buttonInfo = buttons[i]
+                self.LogInfo(`OPCUAIf: monitored item changed: ${buttonInfo.buttonID} ${buttonInfo.attribute} ${nodeId} => ${dataValue.value.value}\n`);
+                self.emit('monitored item changed', buttonInfo.buttonID, buttonInfo.attribute, nodeId, dataValue.value.value)
+            }
+        });
+
+        return monitoredItem.monitoredItemId;
+    }
+
+    async Read(nodeID) {
+        const nodeToRead = {
+            nodeId: nodeID,
+            attributeId: AttributeIds.Value
+        };
+        if (!this.#connected) {
+            this.LogError(`OPCUAIf: not connected, cannot read ${nodeID}\n`);
+            return
+        }
+        const dataValue2 = await this.#session.read(nodeToRead, 0);
+        this.LogError("OPCUAIf: read nodeID ", nodeID, dataValue2.toString(), "\n");
+        return dataValue2
+    }
+
+    async Write(nodeID, value, datatype = DataType.String) {
+        let self = this
+        if (!this.#connected) {
+            self.LogError("OPCUAIf: not connected, cannot write", nodeID, value, "\n");
+            return
+        }
+        var nodesToWrite = [{
+            nodeId: nodeID,
+            attributeId: AttributeIds.Value,
+            indexRange: null,
+            value: {
+                value: {
+                    dataType: datatype,
+                    value: value
+                }
+            }
+        }];
+        try {
+            await this.#session.write(nodesToWrite, function (err, statusCodes) {
+                if (!err) {
+                    if (statusCodes && statusCodes[0].value != 0) {
+                        self.LogInfo(`OPCUAIf: error with Node: "${nodeID}", status ${statusCodes[0]}\n`);
+                    } else {
+                        self.LogInfo(`OPCUAIf: wrote ${nodeID} => ${value}\n`);
+                    }
+                } else {
+                    self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}\n`);
+                }
+            });
+        } catch (err) {
+            self.LogError(`OPCUAIf: writing not OK ${nodeID} => ${value}, ${err}\n`);
+        }
+    }
+}