loupedeck-commander 1.2.7 → 1.2.9

package/common/ApplicationConfig.mjs

@@ -1,4 +1,4 @@
-import { readJSONFile, writeJSONFile } from './utils.mjs'
+import { readJSONFile, writeJSONFile,syncParams } from './utils.mjs'
 
 export class ApplicationConfig {
   application = 'undefined'
@@ -42,6 +42,7 @@ class Profile {
   knobs = {}
   buttons = {}
   parameters = {}
+  default = {}
   #file = ''
   loaded = false
   #error = true
@@ -57,6 +58,7 @@ class Profile {
     this.buttons = new ButtonConfig().buttons
     this.knobs = new KnobsConfig().knobs
     this.parameters = new ParametersConfig().parameters
+    this.default = new DefaultConfig().default
     
     this.loadFromFile(this.#file)
     if (this.#error) { this.saveToFile(`profile-${this.name}-sav.json`) }
@@ -83,15 +85,16 @@ class Profile {
     }
     this.profile = config.profile
     this.description = config.description
+    // Load Parameters.parameters = config.parameters
+    this.parameters = new ParametersConfig(config.parameters).parameters
+    this.default = new DefaultConfig(config.default).default
 
     // Load the Configurations for Touch-Displays
-    this.touch = new TouchConfig(config.touch)
+    this.touch = new TouchConfig(config.touch,this.default)
     // Load the Configurations for Button-Areas
     
     this.buttons = new ButtonConfig(config.buttons,this.#profileCount,this.#index).buttons 
     this.knobs = new KnobsConfig(config.knobs).knobs 
-    // Load Parameters.parameters = config.parameters
-    this.parameters = new ParametersConfig(config.parameters).parameters
 
     this.#error = false
     this.loaded = true
@@ -132,11 +135,11 @@ class TouchConfig {
   } // RIGHT Display Config - Available in CT & LIVE
   //knob = {} // KNOB Display Config - Available only in CT
 
-  constructor (data) {
-    this.loadFromJSON(data)
+  constructor (data,defaultState) {
+    this.loadFromJSON(data,defaultState)
   }
 
-  loadFromJSON (data) {
+  loadFromJSON (data,defaultState) {
     if (!data)
       return
     if (!data.center)
@@ -150,7 +153,21 @@ class TouchConfig {
     this.center = data.center
     this.left = data.left
     this.right = data.right
-    //this.knob = data.knob
+
+    /**
+     * Sychronize the states of the buttons with the default state - add missing options from default state
+     */
+    var buttons = Object.keys(this.center)
+    for (var buttonID=0;buttonID<buttons.length;buttonID++){
+      if (!this.center[buttonID])
+          continue
+      var states = Object.keys(this.center[buttonID].states)
+      for (var stateID=0;stateID<states.length;stateID++){
+          var stateKey = states[stateID]
+          var stateOld = this.center[buttonID].states[stateKey]
+          this.center[buttonID].states[stateKey] = syncParams(stateOld,defaultState)
+      }
+    }
   }
 }
 
@@ -221,8 +238,10 @@ class ParametersConfig {
   parameters = {
     "hostname": "127.0.0.1",
     "endpointurl": "opc.tcp://{hostname}:4840",
-    "nodeid" : "ns=0;s=nodeID"
-  } // KNOB Config - Available only in CT
+    "nodeid" : "ns=0;s=nodeID",
+    "min" : 0,
+    "max" : 100
+  }
 
   constructor (data) {
     this.loadFromJSON(data)
@@ -234,3 +253,20 @@ class ParametersConfig {
     this.parameters = data
   }
 }
+
+class DefaultConfig {
+  default = {
+    "filter": "released",
+    "color":  "#111111"
+  }
+
+  constructor (data) {
+    this.loadFromJSON(data)
+  }
+
+  loadFromJSON (data) {
+    if (!data)
+      return
+    this.default = data
+  }
+}

package/common/BaseLoupeDeckHandler.mjs

@@ -166,6 +166,8 @@ export class BaseLoupeDeckHandler {
     await this.updateScreens()
         
     await this.buttons.draw(this.device)
+    // Initialize the Interfaces
+    await InitializeInterfaces(profile)
     
   }
 
@@ -186,8 +188,9 @@ export class BaseLoupeDeckHandler {
     
     await this.activateProfile(0)
 
-    var profile = this.getCurrentProfile()
-    await InitializeInterfaces(profile,this.buttons.setState)
+    // move into activate profile function to call init with every profile change
+    // var profile = this.getCurrentProfile()
+    //await InitializeInterfaces(profile)
 
     const self = this
 
@@ -333,6 +336,7 @@ export class BaseLoupeDeckHandler {
     this.screenUpdate["right"] = true
 
     ok = await this.screens.center.changed(buttonID,nodeid,val)
+    ok = await this.knobs.changed(buttonID,nodeid,val)
     
     await this.updateScreens()
     return ok

package/common/touchbuttons.mjs

@@ -5,7 +5,7 @@ import * as shellif from '../interfaces/shellif.mjs'
 import * as httpif from '../interfaces/httpif.mjs'
 import * as opcuaif from '../interfaces/opcuaif.mjs'
 import format from 'string-template'
-import { calcDelta } from './utils.mjs'
+import { calcDelta, invertColor } from './utils.mjs'
 import { EventEmitter } from 'node:events'
 
 
@@ -13,17 +13,18 @@ export var opcuainterface = undefined
 var httpinterface = undefined
 var shellinterface = undefined
 export var profileEmitter = undefined
-export async function InitializeInterfaces(appConfig,callbackFunction){
+export async function InitializeInterfaces(appConfig){
   if (opcuainterface === undefined ){
     opcuainterface = new opcuaif.OPCUAIf()
-    opcuainterface.init(appConfig.parameters,appConfig,callbackFunction)
   }
+  // the opcua interface needs the profile to register nodes with subscriptions:
+  opcuainterface.init(appConfig.parameters,appConfig)
   if (httpinterface === undefined) 
     httpinterface = new httpif.HTTPif()
   if (shellinterface === undefined)
     shellinterface = new shellif.SHELLif()
-
-  profileEmitter = new EventEmitter()
+  if (profileEmitter === undefined)
+    profileEmitter = new EventEmitter()
 }
 
 export async function StopInterfaces(){
@@ -81,7 +82,7 @@ export class ButtonField {
     const keys = Object.keys(data)
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i]
-      const tb = new Button(`${this.#type}-${key}`, width / columns, height / rows, data[key],key,this.#profile.parameters)
+      const tb = new Button(`${this.#type}-${key}`, width / columns, height / rows, data[key],key,this.#profile)
       this.#buttons[key] = tb
     }
 
@@ -191,6 +192,8 @@ export class ButtonField {
 
 export class Button {
   #profile
+  #params
+  #data
   width = 0
   height = 0
 
@@ -229,7 +232,7 @@ export class Button {
   minPressed = 25
   key = -1
 
-  constructor (id, width, height, data,key,params) {
+  constructor (id, width, height, data,key,profile) {
     this.id = id
     this.key = key
     this.width = width
@@ -237,8 +240,10 @@ export class Button {
     this.#index = 0
 
     if (data && data.states) {
-      this.group = data.group
+      this.#data = data
 
+      this.group = data.group
+      
       this.#states = data.states
       this.#keys = Object.keys(this.#states)
       if (data.type) {
@@ -253,12 +258,23 @@ export class Button {
         this.text = data.text
       }
     }
+    if (profile === undefined){
+      this.#profile = {}
+      this.#params = {}
+    }else{
+      this.#profile = profile
+      this.#params = profile.parameters
+      if (profile.parameters.min !== undefined)
+        this.#min = profile.parameters.min
+      if (profile.parameters.max !== undefined)
+        this.#max = profile.parameters.max
+    }
     if (this.#states === undefined) {
       this.#states = {}
       this.#keys = []
     }
     if (data.nodeid){
-      this.#nodeid = format(data.nodeid, params)
+      this.#nodeid = format(data.nodeid, this.#params)
     }
     if (data.default) {
       this.#index = this.#keys.indexOf(data.default)
@@ -308,8 +324,10 @@ export class Button {
       }
     }
     if (this.text){
-      const lastElem = this.getLastElement()
-      ctx.fillStyle = lastElem.color
+      //const lastElem = this.getLastElement()
+      // Only change the text color, if it differnce from the currently set color
+      
+      ctx.fillStyle = invertColor(elem.color)
       ctx.font = '20px Verdana'
       ctx.textBaseline = 'top';
       ctx.textAlign = 'left';
@@ -408,7 +426,7 @@ export class Button {
     if (!this.getCurrentElement()) { return false }
 
     this.#event = "rotated"
-    this.#value = calcDelta(this.#value, delta, this.#max)
+    this.#value = calcDelta(this.#value, delta, this.#min, this.#max)
     return this.runCommand()
   }
 
@@ -429,20 +447,21 @@ export class Button {
 
       // check if the nodeid is the same and the value is one of the states
         let state = this.#states[key]
-        if (!state.value)
+        if (state.value === undefined)
           continue
 
         const params = {
           id: buttonID,
           key: buttonID,
+          state : key,
           ...state
         }
         let val1 = format(state.value,params)
-        if (val1 === val){
+        if (val1 === val.toString()){
           this.#index = i;
           break;
         }
-        break;
+        //break;
     }
   }
 
@@ -507,7 +526,7 @@ export class Button {
       y: (this.#y %100)
     }
 
-    if (!params.value)
+    if (params.value === undefined)
       params.value = this.#value
 
 
@@ -529,6 +548,12 @@ export class Button {
     if ('opcua' in elem) {
       if (opcuainterface){
         res = await opcuainterface.call(elem.opcua, params)
+
+        if (this.#data.statenodeid){
+          let stateParams = params
+          params.value = params.state
+          res = await opcuainterface.call(this.#data.statenodeid, params)
+        }
       }else{
         console.warn("opcuainterface not started")
       }

package/common/utils.mjs

@@ -22,9 +22,64 @@ export function writeJSONFile (fileName, jsonObj) {
   writeFileSync(fileName, data)
 }
 
-export function calcDelta (data, delta, max = 100) {
+/**
+ * Calculate the delta of a value within a range between min and max with overflow
+ * @param {*} data 
+ * @param {*} delta 
+ * @param {*} min 
+ * @param {*} max 
+ * @returns 
+ */
+export function calcDelta (data, delta, min = 0, max = 100) {
   data = data + delta
-  if (data > max) { data = max }
-  if (data < 0) { data = 0 }
+  if (data > max) { data = min }
+  else if (data < min) { data = max }
   return data
 }
+
+/**
+ * Invert a color in hex format (#RRGGBB) to its inverted color
+ * @param {*} colorAsHex 
+ * @returns 
+ */
+export function invertColor(colorAsHex){
+  let rgb = colorToRGB(colorAsHex)
+  for (var i = 0; i < rgb.length; i++) {
+    rgb[i] = (i === 3 ? 1 : 255) - rgb[i];
+  }
+  let invertedColor = `#${rgb[0].toString(16)}${rgb[1].toString(16)}${rgb[2].toString(16)})`
+  //let invertedColor = `#${rgb[0].toString(16).padStart(2, '0')}${rgb[1].toString(16).padStart(2, '0')}${rgb[2].toString(16).padStart(2, '0')})`
+  //console.log("invert", colorAsHex,"=>",invertedColor)
+  return invertedColor
+}
+
+/**
+ * Convert a color in hex format (#RRGGBB) to RGB array
+ * @param {*} colorAsHex 
+ * @returns 
+ */
+export function colorToRGB(colorAsHex){
+  const r = parseInt(colorAsHex.slice(1, 3), 16)
+  const g = parseInt(colorAsHex.slice(3, 5), 16)
+  const b = parseInt(colorAsHex.slice(5, 7), 16)
+  return [r,g,b]
+}
+
+/**
+ * Synchronize the parameters of a node with the default node
+ * @param {*} node 
+ * @param {*} defaultnode 
+ * @returns node
+ */
+export function syncParams(node, defaultnode){
+  if (node === undefined || defaultnode === undefined)
+    return node
+  let keys = Object.keys(defaultnode)
+  for (var i=0;i<keys.length;i++){
+    let key = keys[i]
+    if (!(key in node))
+      node[key] = defaultnode[key]
+  }
+  return node
+}
+

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,22 +33,22 @@ export class OPCUAIf extends BaseIf {
     #sub
     #connected
     #endpointurl
+    #publishingInterval
     monitoreditems
     types
     buttons
-    #callback
     constructor() {
         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
@@ -61,35 +61,47 @@ export class OPCUAIf extends BaseIf {
      * @param {*} config 
      * @param {*} callbackFunction 
      */
-    async init( options = {},config = {},callbackFunction){
+    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)
-            this.#callback = callbackFunction
+        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]
-                    if (elem.nodeid){
-                        let format = this.formatString(elem.nodeid,options)
+                    // groupnode
+                    if (elem.nodeid) {
+                        let format = this.formatString(elem.nodeid, options)
                         let monitoredItemId = await this.Subscribe(format)
                         this.buttons[monitoredItemId] = i
                     }
-                    await this.monitorStates(elem,options)
+                    // statenode
+                    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)
                 }
             }
         } catch (error) {
@@ -102,17 +114,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
             }
-        }    
+        }
     }
 
     /**
@@ -125,17 +137,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")
@@ -146,15 +158,24 @@ export class OPCUAIf extends BaseIf {
                 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
         }
     }
 
-    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
         }
 
@@ -165,34 +186,41 @@ 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()
             this.LogInfo(`OPCUAIf: Disconnected\n`);
@@ -202,7 +230,7 @@ export class OPCUAIf extends BaseIf {
         let self = this
         this.#client = OPCUAClient.create({
             applicationName: "NodeOPCUA-Client",
-    
+
             endpointMustExist: false,
             // keepSessionAlive: true,
             requestedSessionTimeout: 60 * 1000,
@@ -213,44 +241,44 @@ export class OPCUAIf extends BaseIf {
                 maxDelay: 5000,
                 initialDelay: 2500
             },
-    
+
             defaultSecureTokenLifetime: 20000,
             tokenRenewalInterval: 1000
         });
-    
+
         this.#client.on("backoff", (retry, delay) => {
-            if((retry%10) == 0)
+            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`);
         })
@@ -263,13 +291,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());
@@ -278,7 +307,7 @@ export class OPCUAIf extends BaseIf {
         this.#connected = true
         this.#endpointurl = url
     }
-    
+
     async Subscribe(nodeID) {
         // install monitored item
 
@@ -286,7 +315,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
             }
@@ -301,14 +330,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]
@@ -316,55 +345,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.7",
+  "version": "1.2.9",
   "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    
     }

package/numbers/README.md

@@ -1,5 +0,0 @@
-# Numbers Icons
-
-Downloaded from:
-
-- https://www.freepik.com/author/moniruldislam/icons/generic-color-lineal-color_10172?query=Number#from_element=families

package/profile-profile-1-sav.json

@@ -1,373 +0,0 @@
-{
-    "name": "profile-1",
-    "profile": "example",
-    "description": "",
-    "touch": {
-        "center": {
-            "0": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "1": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "2": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "3": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "4": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "5": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "6": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "7": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "8": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "9": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "10": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            },
-            "11": {
-                "states": {
-                    "off": {
-                        "color": "#000099",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    },
-                    "on": {
-                        "color": "#00ff00",
-                        "image": "icons/home.png",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            }
-        },
-        "left": {
-            "0": {
-                "states": {
-                    "on": {
-                        "color": "#000000",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            }
-        },
-        "right": {
-            "0": {
-                "states": {
-                    "on": {
-                        "color": "#000000",
-                        "cmd": "echo \"{id} {state}\""
-                    }
-                },
-                "group": ""
-            }
-        }
-    },
-    "knobs": {
-        "knobTL": {
-            "states": {
-                "on": {
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "knobCL": {
-            "states": {
-                "on": {
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "knobBL": {
-            "states": {
-                "on": {
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "knobTR": {
-            "states": {
-                "on": {
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "knobCR": {
-            "states": {
-                "on": {
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "knobBR": {
-            "states": {
-                "on": {
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        }
-    },
-    "buttons": {
-        "0": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#550000",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "1": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#ff0000",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "2": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#005500",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "3": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#00ff00",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "4": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#000055",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "5": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#0000ff",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "6": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#555500",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        },
-        "7": {
-            "states": {
-                "off": {
-                    "color": "#000000",
-                    "cmd": "echo \"{id} {state}\""
-                },
-                "on": {
-                    "color": "#ffff00",
-                    "cmd": "echo \"{id} {state}\""
-                }
-            },
-            "group": ""
-        }
-    },
-    "parameters": {
-        "hostname": "127.0.0.1",
-        "endpointurl": "opc.tcp://{hostname}:4840",
-        "nodeid": "ns=0;s=nodeID"
-    },
-    "loaded": false
-}