loupedeck-commander 1.2.8 → 1.2.10

package/common/touchbuttons.mjs

@@ -456,10 +456,13 @@ export class Button {
           state : key,
           ...state
         }
-        let val1 = format(state.value,params)
-        if (val1 === val.toString()){
-          this.#index = i;
-          break;
+        if (state && state.value !== undefined){
+          let strVal = state.value.toString()
+          let val1 = format(strVal,params)
+          if (val1 === val?.toString()){
+            this.#index = i;
+            break;
+          }
         }
         //break;
     }

package/config.json

@@ -4,10 +4,6 @@
         {
             "name": "profile-1",
             "file": "profile-1.json"
-        },
-        {
-            "name": "profile-2",
-            "file": "profile-2.json"
         }
     ]
 }

package/interfaces/opcuaif.mjs

@@ -33,6 +33,7 @@ export class OPCUAIf extends BaseIf {
     #sub
     #connected
     #endpointurl
+    #publishingInterval
     monitoreditems
     types
     buttons
@@ -40,14 +41,14 @@ export class OPCUAIf extends BaseIf {
         super()
 
         this.LogInfo(`OPCUAIf Constructed`);
-      }
+    }
 
-    async stop(){
+    async stop() {
         if (!this.#client)
             return
-        
+
         this.LogInfo(`OPCUAIf Stopping\n`)
-        await this.#client.closeSession(this.#session,true)
+        await this.#client.closeSession(this.#session, true)
         await this.#client.disconnect()
         this.#connected = false
         this.#client = null
@@ -60,41 +61,49 @@ export class OPCUAIf extends BaseIf {
      * @param {*} config 
      * @param {*} callbackFunction 
      */
-    async init( options = {},config = {}){
+    async init(options = {}, config = {}) {
         var res = this.Check(options)
-        if (res<0){
+        if (res < 0) {
             this.LogError(`OPCUAIf: Missing essential options in dictionary => Quitting $res $options\n`)
         }
-        try{
-            this.#endpointurl = this.formatString(options.endpointurl,options)
+        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`);
+            }
             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]
             const fieldKeys = Object.keys(fields)
             for (let f = 0; f < fieldKeys.length; f++) {
-                let field=fields[f]
+                let field = fields[f]
                 const keys = Object.keys(field)
                 for (let i = 0; i < keys.length; i++) {
                     const key = keys[i]
                     const elem = field[key]
                     // groupnode
-                    if (elem.nodeid){
-                        let format = this.formatString(elem.nodeid,options)
-                        let monitoredItemId = await this.Subscribe(format)
+                    if (elem.nodeid) {
+                        options["key"] = key
+                        let formattedNodeId = this.formatString(elem.nodeid, options)
+                        let monitoredItemId = await this.Subscribe(formattedNodeId)
+                        console.log("Subscribe to",formattedNodeId)
                         this.buttons[monitoredItemId] = i
                     }
                     // statenode
-                    if (elem.statenodeid){
-                        let format = this.formatString(elem.statenodeid,options)
+                    if (elem.statenodeid) {
+                        let format = this.formatString(elem.statenodeid, options)
                         let monitoredItemId = await this.Subscribe(format)
                         this.buttons[monitoredItemId] = i
                     }
-                    await this.monitorStates(elem,options)
+                    await this.monitorStates(elem, options)
                 }
             }
         } catch (error) {
@@ -107,17 +116,17 @@ export class OPCUAIf extends BaseIf {
      * @param {*} elem : Elem Object
      * @param {*} options 
      */
-    async monitorStates(elem,options){
+    async monitorStates(elem, options) {
         const stateKeys = Object.keys(elem.states)
         for (let i = 0; i < stateKeys.length; i++) {
             const key2 = stateKeys[i]
             const state = elem.states[key2]
-            if (state.opcua){
-                let format = this.formatString(state.opcua,options)
+            if (state.opcua) {
+                let format = this.formatString(state.opcua, options)
                 let monitoredItemId = await this.Subscribe(format)
                 this.buttons[monitoredItemId] = i
             }
-        }    
+        }
     }
 
     /**
@@ -130,17 +139,17 @@ export class OPCUAIf extends BaseIf {
      * - DataType.String
      * @returns the converted value.
      */
-    convert(value,type){
-        switch(type){
+    convert(value, type) {
+        switch (type) {
             case DataType.Int16:
             case DataType.Int32:
-                if (typeof value == "number"){
+                if (typeof value == "number") {
                     if (Number.isInteger(value))
                         return value
-                    else 
+                    else
                         return Math.trunc(value)
                 }
-                return parseInt(value,10)
+                return parseInt(value, 10)
                 break
             case DataType.Float:
                 if (typeof value == "number")
@@ -154,8 +163,8 @@ export class OPCUAIf extends BaseIf {
             case DataType.Boolean:
                 if (typeof value == "number" && value === 1)
                     return true
-                if (typeof value == "string"){
-                    if (["true","on"].includes(value)){
+                if (typeof value == "string") {
+                    if (["true", "on"].includes(value)) {
                         return true
                     }
                 }
@@ -165,10 +174,10 @@ export class OPCUAIf extends BaseIf {
         }
     }
 
-    async call (opcuaNode, options = {}) {
+    async call(opcuaNode, options = {}) {
         var res = this.Check(options)
-        if (res<0){
-//            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res\n`)
+        if (res < 0) {
+            //            this.LogError(`OPCUAIf call: Missing essential options in dictionary => Quitting $res\n`)
             return false
         }
 
@@ -179,45 +188,59 @@ export class OPCUAIf extends BaseIf {
         if (typeof value == "string")
             value = super.formatString(options.value, options)
 
-        var convertedValue = this.convert(value,type)
+        var convertedValue = this.convert(value, type)
         this.LogInfo(`OPCUAIf: write ${nodeId} => ${value}\n`)
-        await this.Write(nodeId,convertedValue,type)
+        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`)    
+        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 (!"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}
+        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
     }
 
     async Disconnect() {
-        if (this.#client){
+        if (this.#client) {
             this.LogInfo(`OPCUAIf: Disconnect\n`);
-            await this.#client.Disconnect()
+            if (this.#session)
+                await this.#client.closeSession(this.#session,true)
+            this.#session = undefined
+            this.#client = undefined
             this.LogInfo(`OPCUAIf: Disconnected\n`);
         }
     }
     async Connect(url) {
         let self = this
+        if (this.#client){
+            console.log("Closing session first")
+            await this.Disconnect()
+        }
+        
         this.#client = OPCUAClient.create({
             applicationName: "NodeOPCUA-Client",
-    
-            endpointMustExist: false,
+            endpointMustExist: true,
             // keepSessionAlive: true,
             requestedSessionTimeout: 60 * 1000,
             securityMode: MessageSecurityMode.None,
@@ -227,44 +250,45 @@ export class OPCUAIf extends BaseIf {
                 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`);
+            //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.#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`);
         })
@@ -277,13 +301,14 @@ export class OPCUAIf extends BaseIf {
         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: 1000
+            requestedPublishingInterval: this.#publishingInterval
         });
 
         this.LogInfo(`OPCUAIf: session created\n`);//, this.#session.toString());
@@ -292,7 +317,7 @@ export class OPCUAIf extends BaseIf {
         this.#connected = true
         this.#endpointurl = url
     }
-    
+
     async Subscribe(nodeID) {
         // install monitored item
 
@@ -300,7 +325,7 @@ export class OPCUAIf extends BaseIf {
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i]
             const elem = this.monitoreditems[key]
-            if (elem == nodeID){
+            if (elem == nodeID) {
                 // already registered => return itemid
                 return key
             }
@@ -315,14 +340,14 @@ export class OPCUAIf extends BaseIf {
             discardOldest: true,
             queueSize: 10
         };
-    
-        if (!this.#sub){
+
+        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
+        var self = this
         monitoredItem.on("changed", function (dataValue) {
             var nodeId = self.monitoreditems[this.monitoredItemId]
             var buttonID = self.buttons[this.monitoredItemId]
@@ -330,55 +355,59 @@ export class OPCUAIf extends BaseIf {
             self.types[nodeId] = dataValue.value.dataType
             // publish the value to subscribers:
             self.LogInfo(`OPCUAIf: monitored item changed: ${nodeId} => ${dataValue.value.value}\n`);
-            self.emit('monitored item changed',buttonID,nodeId, dataValue.value.value)
+            self.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){
+        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");
+        this.LogError("OPCUAIf: read nodeID ", nodeID, dataValue2.toString(), "\n");
         return dataValue2
     }
 
-    async Write(nodeID,value,datatype=DataType.String) {
+    async Write(nodeID, value, datatype = DataType.String) {
         let self = this
-        if (!this.#connected){
-            self.LogError("OPCUAIf: not connected, cannot write",nodeID, value,"\n");
+        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: { 
+            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: error with Node: "${nodeID}", status ${statusCodes[0]}\n`);
-                }else{
-                    self.LogInfo(`OPCUAIf: wrote ${nodeID} => ${value}\n`);
+        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: write NOT ok", nodeID, value, "\n");
+                    self.LogError(err)
                 }
-            }else{
-                self.LogError("OPCUAIf: write NOT ok",nodeID, value,"\n");
-                self.LogError(err)
-            }
-        });  
+            });
+        } catch (err) {
+            self.LogError("OPCUAIf: write NOT ok", nodeID, value, "\n");
+            self.LogError(err)
+        }
     }
 }
-  

package/interfaces/shellif.mjs

@@ -6,23 +6,23 @@ import { BaseIf } from './baseif.mjs'
  * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
  */
 export class SHELLif extends BaseIf {
-  async call (cmd, options = {}) {
+  async call(cmd, options = {}) {
     var res = this.Check(options)
-    if (res<0){
-        return false
+    if (res < 0) {
+      return false
     }
     let formattedCmd = super.call(cmd, options)
     return await this.sh(formattedCmd)
   }
 
-  async stop(){
+  async stop() {
     this.LogInfo("SHELLif: Stopping")
   }
 
   Check(options) {
-    var res= super.Check(options)
-    if (res <0){
-      this.LogError(`SHELLif: mandatory parameter missing\n`)    
+    var res = super.Check(options)
+    if (res < 0) {
+      this.LogError(`SHELLif: mandatory parameter missing\n`)
       return res
     }
   }
@@ -32,22 +32,27 @@ export class SHELLif extends BaseIf {
    * @param {*} cmd 
    * @returns 
    */
-  async sh (cmd) {
-    let self = this; 
+  async sh(cmd) {
+    let self = this;
     this.LogDebug(`ShellIf: runCmd: ${cmd}\n`)
-    
+
     return new Promise(function (resolve, reject) {
-      exec(cmd, (err, stdout, stderr) => {
-        if (stdout.length>0)
-          self.LogInfo(`SHELLif Out: ${stdout}`)
-        if (stderr.length>0)
-          self.LogError(`SHELLif Err: ${stderr}`)
-        if (err) {
-          reject(err)
-        } else {
-          resolve({ stdout, stderr })
-        }
-      })
+      try {
+        exec(cmd, (err, stdout, stderr) => {
+          if (stdout.length > 0)
+            self.LogInfo(`SHELLif Out: ${stdout}`)
+          if (stderr.length > 0)
+            self.LogError(`SHELLif Err: ${stderr}`)
+          if (err) {
+            resolve(err)
+          } else {
+            resolve({ stdout, stderr })
+          }
+        })
+      } catch (e) {
+        console.error(`Error in script: ${e}`)
+        resolve()
+      }
     })
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loupedeck-commander",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "A system to ease working with LoupeDeck devices using CMD-line, OPC/UA or HTTP-client interfaces",
   "main": "index.mjs",
   "scripts": {

package/profile-1.json

@@ -229,7 +229,7 @@
             "states": {
                 "on": {
                     "cmd": "echo \"{id} {state}\"",
-                    "opcua": "ns=2;s=Is{simnbr}.Audio.in.VolumeAccustic"
+                    "opcua": "ns=1;s={simnbr}.Function1"
                 }
             },
             "group": ""
@@ -263,6 +263,7 @@
         "hostname": "127.0.0.1",
         "simnbr": "1",
         "endpointurl": "opc.tcp://{hostname}:4840",
+        "publishingInterval" : 200,
         "nodeid" : "ns=0;s=nodeID",
         "verbose": true    
     }