loupedeck-commander 1.2.0 → 1.2.2

package/interfaces/opcuaif.mjs

@@ -1,287 +1,283 @@
-import {
-    OPCUAClient,
-    MessageSecurityMode,
-    SecurityPolicy,
-    BrowseDirection,
-    AttributeIds,
-    NodeClassMask,
-    makeBrowsePath,
-    resolveNodeId,
-    TimestampsToReturn,
-    coerceInt32,
-    coerceByteString,
-    DataType
-} from "node-opcua";
-import { EventEmitter } from 'node:events'
-import { BaseIf } from './baseif.mjs'
-
-const subscriptionParameters = {
-    maxNotificationsPerPublish: 1000,
-    publishingEnabled: true,
-    requestedLifetimeCount: 100,
-    requestedMaxKeepAliveCount: 10,
-    requestedPublishingInterval: 1000
-};
-
-
-/**
- * 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
-    monitoreditems
-    buttons
-    #callback
-    myEmitter
-    constructor() {
-        super()
-        this.myEmitter = new EventEmitter();
-
-        console.log("OPCUAIf Constructed");
-      }
-
-    async stop(){
-        if (!this.#client)
-            return
-        
-        console.log("Stopping OPC/UA")
-        await this.#client.closeSession(this.#session,true)
-        await this.#client.disconnect()
-        this.#connected = false
-        this.#client = null
-        console.log("Stopped OPC/UA")
-    }
-
-    async init( options = {},config = {},callbackFunction){
-        var res = this.Check(options)
-        if (res<0){
-            console.error("OpcuaIf init: Missing essential options in dictionary => Quitting\n",res,options)
-        }
-        try{
-            this.#endpointurl = options.endpointurl
-            this.#callback = callbackFunction
-            this.monitoreditems = {}
-            this.buttons = {}
-            console.log("OPCUAIf init",this.#endpointurl);
-        
-            await this.Connect(this.#endpointurl);
-
-            let field=config.touch.center
-            const keys = Object.keys(field)
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i]
-                const elem = config.touch.center[key]
-                if (elem.nodeid){
-                    let format = this.formatString(elem.nodeid,options)
-                    let monitoredItemId = await this.Subscribe(format)
-                    this.buttons[monitoredItemId] = i
-                }
-
-            }
-        } catch (error) {
-        console.log(' Error', error)
-        }
-    }
-
-    async call (opcuaNode, options = {}) {
-        var res = this.Check(options)
-        if (res<0){
-            console.error("OpcuaIf call: Missing essential options in dictionary => Quitting\n",res,options)
-            return false
-        }
-
-        var nodeId = super.formatString(opcuaNode, options)
-        var value = super.formatString(options.value, options)
-
-        console.log("OPCUAIf:write", nodeId, value)
-        await this.Write(nodeId,value)
-
-        var NewState = "waiting"
-        return NewState
-    }
-
-    Check(options) {
-        var res= super.Check(options)
-        if (res <0)
-            return res
-        if (!options.endpointurl)
-            return -11
-        if (!options.nodeid)
-            return -12
-        if (!options.value)
-            return -13
-        return 0
-    }
-
-    async Disconnect() {
-        if (this.#client){
-            console.log("Disconnect !");
-            await this.#client.Disconnect()
-            console.log("Done !");
-        }
-    }
-    async Connect(url) {
-        let self = this
-        this.#client = OPCUAClient.create({
-            applicationName: "NodeOPCUA-Client",
-    
-            endpointMustExist: false,
-            // keepSessionAlive: true,
-            requestedSessionTimeout: 60 * 1000,
-            securityMode: MessageSecurityMode.None,
-            securityPolicy: SecurityPolicy.None,
-            connectionStrategy: {
-                maxRetry: -1,
-                maxDelay: 2500,
-                initialDelay: 100
-            },
-    
-            defaultSecureTokenLifetime: 20000,
-            tokenRenewalInterval: 1000
-        });
-    
-        this.#client.on("backoff", (retry, delay) => {
-            console.log("Backoff ", retry, " next attempt in ", delay, "ms", self.#endpointurl);
-        });
-    
-        this.#client.on("connection_lost", () => {
-            console.log("Connection lost");
-        });
-    
-        this.#client.on("connection_reestablished", () => {
-            console.log("Connection re-established");
-        });
-    
-        this.#client.on("connection_failed", () => {
-            console.log("Connection failed");
-        });
-        this.#client.on("start_reconnection", () => {
-            console.log("Starting reconnection");
-        });
-    
-        this.#client.on("after_reconnection", (err) => {
-            console.log("After Reconnection event =>", err);
-        });
-        this.#client.on("security_token_renewed", () => {
-            //console.log("security_token_renewed =>");
-            //console.log(this.#client.toString());
-        })
-        this.#client.on("lifetime_75", (token) => {
-            //// /*ChannelSecurityToken*/
-            //console.log("lifetime_75 =>", token.toString());
-        })
-    
-        console.log("connecting client to url",url);//, this.#session.toString());
-        await this.#client.connect(url);
-    
-        this.#session = await this.#client.createSession();
-    
-        this.#session.on("session_closed", (statusCode) => {
-            console.log(" Session has been closed with statusCode = ", statusCode.toString());
-        })
-        this.#session.on("session_restored", () => {
-            console.log(" Session has been restored");
-        });
-        this.#session.on("keepalive", (lastKnownServerState) => {
-            console.log("KeepAlive lastKnownServerState", lastKnownServerState);
-        });
-        this.#session.on("keepalive_failure", () => {
-            console.log("KeepAlive failure");
-        });
-    
-        this.#sub = await this.#session.createSubscription2({
-            maxNotificationsPerPublish: 9000,
-            publishingEnabled: true,
-            requestedLifetimeCount: 10,
-            requestedMaxKeepAliveCount: 10,
-            requestedPublishingInterval: 1000
-        });
-
-        this.LogInfo("session created\n");//, this.#session.toString());
-        this.LogInfo("client\n", this.#client.toString());
-        this.LogInfo("subscription\n",this.#sub.toString());
-        this.#connected = true
-        this.#endpointurl = url
-    }
-    
-    async Subscribe(nodeID) {
-        // install monitored item
-        const itemToMonitor = {
-            nodeId: resolveNodeId(nodeID),
-            attributeId: AttributeIds.Value
-        };
-        const monitoringParameters = {
-            samplingInterval: 100,
-            discardOldest: true,
-            queueSize: 10
-        };
-    
-        if (!this.#sub){
-            this.LogError(" not register monitored items",itemToMonitor);
-            return
-        }
-        const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
-        this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
-        var self=this
-        //monitoredItem.on("changed", this.MonitoredItemUpdate)
-        monitoredItem.on("changed", function (dataValue) {
-            var nodeId = self.monitoreditems[this.monitoredItemId]
-            var buttonID = self.buttons[this.monitoredItemId]
-            //console.log("monitored item changed:  ", this.monitoredItemId,nodeId, dataValue.value.value);
-            self.myEmitter.emit('monitored item changed',buttonID,nodeId, dataValue.value.value)
-        });
-
-        return monitoredItem.monitoredItemId;
-    }
-    
-    async Read(nodeID) {
-        const nodeToRead = {
-            nodeId: nodeID,
-            attributeId: AttributeIds.Value
-        };
-        if (!this.#connected){
-            this.LogError(" not connected, cannot read",nodeID);
-            return
-        }
-        const dataValue2 = await this.#session.read(nodeToRead, 0);
-        this.LogError("read: nodeID ",nodeID, dataValue2.toString());
-        return dataValue2
-    }
-
-    async Write(nodeID,value,datatype=DataType.String) {
-        let self = this
-        if (!this.#connected){
-            self.LogError(" not connected, cannot write",nodeID, value);
-            return
-        }
-        var nodesToWrite = [{
-            nodeId: nodeID,
-            attributeId: AttributeIds.Value,
-            indexRange: null,
-            value: { 
-                value: { 
-                    dataType: datatype,
-                    value: value
-                }
-          }
-        }];
-        await this.#session.write(nodesToWrite, function(err,statusCodes) {
-            if (!err) {              
-                if (statusCodes && statusCodes[0].value != 0){
-                    self.LogInfo("status", statusCodes);
-                }else{
-                    self.LogInfo(" write ok",nodeID, value);
-                }
-            }else{
-                self.LogError(" write NOT ok",nodeID, value);
-                self.LogError(err)
-            }
-        });  
-    }
-}
+import {
+    OPCUAClient,
+    MessageSecurityMode,
+    SecurityPolicy,
+    BrowseDirection,
+    AttributeIds,
+    NodeClassMask,
+    makeBrowsePath,
+    resolveNodeId,
+    TimestampsToReturn,
+    coerceInt32,
+    coerceByteString,
+    DataType
+} from "node-opcua";
+import { EventEmitter } from 'node:events'
+import { BaseIf } from './baseif.mjs'
+
+const subscriptionParameters = {
+    maxNotificationsPerPublish: 1000,
+    publishingEnabled: true,
+    requestedLifetimeCount: 100,
+    requestedMaxKeepAliveCount: 10,
+    requestedPublishingInterval: 1000
+};
+
+
+/**
+ * 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
+    monitoreditems
+    buttons
+    #callback
+    myEmitter
+    constructor() {
+        super()
+        this.myEmitter = new EventEmitter();
+
+        this.LogInfo(`OPCUAIf Constructed`);
+      }
+
+    async stop(){
+        if (!this.#client)
+            return
+        
+        this.LogInfo(`OPCUAIf Stopping`)
+        await this.#client.closeSession(this.#session,true)
+        await this.#client.disconnect()
+        this.#connected = false
+        this.#client = null
+        this.LogInfo(`OPCUAIf Stopped\n`)
+    }
+
+    async init( options = {},config = {},callbackFunction){
+        var res = this.Check(options)
+        if (res<0){
+            this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options\n`)
+        }
+        try{
+            this.#endpointurl = options.endpointurl
+            this.#callback = callbackFunction
+            this.monitoreditems = {}
+            this.buttons = {}
+            this.LogInfo(`OPCUAIf init ${this.#endpointurl}\n`);
+        
+            await this.Connect(this.#endpointurl);
+
+            let field=config.touch.center
+            const keys = Object.keys(field)
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i]
+                const elem = config.touch.center[key]
+                if (elem.nodeid){
+                    let format = this.formatString(elem.nodeid,options)
+                    let monitoredItemId = await this.Subscribe(format)
+                    this.buttons[monitoredItemId] = i
+                }
+
+            }
+        } catch (error) {
+            this.LogError(`OPCUAIf: Error $error\n`)
+        }
+    }
+
+    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.formatString(opcuaNode, options)
+        var value = super.formatString(options.value, options)
+
+        this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}\n`)
+        await this.Write(nodeId,value)
+
+        var NewState = "waiting"
+        return NewState
+    }
+
+    Check(options) {
+        var res= super.Check(options)
+        if (res <0)
+            return res
+        if (!options.endpointurl)
+            return -11
+        if (!options.nodeid)
+            return -12
+        if (!options.value)
+            return -13
+        return 0
+    }
+
+    async Disconnect() {
+        if (this.#client){
+            this.LogInfo(`OPCUAIf: Disconnect\n`);
+            await this.#client.Disconnect()
+            this.LogInfo(`OPCUAIf: Disconnected\n`);
+        }
+    }
+    async Connect(url) {
+        let self = this
+        this.#client = OPCUAClient.create({
+            applicationName: "NodeOPCUA-Client",
+    
+            endpointMustExist: false,
+            // 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)
+                this.LogInfo(`OPCUAIf Try Reconnection ${retry} next attempt in ${delay}ms ${self.#endpointurl}\n`);
+        });
+    
+        this.#client.on("connection_lost", () => {
+            this.LogInfo(`OPCUAIf: Connection lost\n`);
+        });
+    
+        this.#client.on("connection_reestablished", () => {
+            this.LogInfo(`OPCUAIf: Connection re-established\n`);
+        });
+    
+        this.#client.on("connection_failed", () => {
+            this.LogInfo(`OPCUAIf: Connection failed\n`);
+        });
+        this.#client.on("start_reconnection", () => {
+            this.LogInfo(`OPCUAIf: Starting reconnection\n`);
+        });
+    
+        this.#client.on("after_reconnection", (err) => {
+            this.LogInfo(`OPCUAIf: After Reconnection event => ${err}\n`);
+        });
+        this.#client.on("security_token_renewed", () => {
+            this.LogInfo(`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) => {
+            this.LogInfo(`OPCUAIf: Session has been closed\n`);
+        })
+        this.#session.on("session_restored", () => {
+            this.LogInfo(`OPCUAIf: Session has been restored\n`);
+        });
+        this.#session.on("keepalive", (lastKnownServerState) => {
+            this.LogInfo(`OPCUAIf: KeepAlive lastKnownServerState ${lastKnownServerState}\n`);
+        });
+        this.#session.on("keepalive_failure", () => {
+            this.LogInfo(`OPCUAIf: KeepAlive failure\n`);
+        });
+    
+        this.#sub = await this.#session.createSubscription2({
+            maxNotificationsPerPublish: 9000,
+            publishingEnabled: true,
+            requestedLifetimeCount: 10,
+            requestedMaxKeepAliveCount: 10,
+            requestedPublishingInterval: 1000
+        });
+
+        this.LogInfo(`OPCUAIf: session created\n`);//, this.#session.toString());
+        this.LogInfo(`OPCUAIf: client\n`);
+        this.LogInfo(`OPCUAIf: subscription\n`);
+        this.#connected = true
+        this.#endpointurl = url
+    }
+    
+    async Subscribe(nodeID) {
+        // install monitored item
+        const itemToMonitor = {
+            nodeId: resolveNodeId(nodeID),
+            attributeId: AttributeIds.Value
+        };
+        const monitoringParameters = {
+            samplingInterval: 100,
+            discardOldest: true,
+            queueSize: 10
+        };
+    
+        if (!this.#sub){
+            this.LogError(`OPCUAIf: not register monitored items $itemToMonitor\n`);
+            return
+        }
+        const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
+        this.monitoreditems[monitoredItem.monitoredItemId] = nodeID
+        var self=this
+        monitoredItem.on("changed", function (dataValue) {
+            var nodeId = self.monitoreditems[this.monitoredItemId]
+            var buttonID = self.buttons[this.monitoredItemId]
+            this.LogDebug("OPCUAIf: monitored item changed:  ", this.monitoredItemId,nodeId, dataValue.value.value,"\n");
+            self.myEmitter.emit('monitored item changed',buttonID,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
+                }
+          }
+        }];
+        await this.#session.write(nodesToWrite, function(err,statusCodes) {
+            if (!err) {              
+                if (statusCodes && statusCodes[0].value != 0){
+                    self.LogInfo(`OPCUAIf: status $statusCodes\n`);
+                }else{
+                    self.LogInfo(`OPCUAIf: wrote $nodeID => $value\n`);
+                }
+            }else{
+                self.LogError("OPCUAIf: write NOT ok",nodeID, value,"\n");
+                self.LogError(err)
+            }
+        });  
+    }
+}