loupedeck-commander 1.3.1 → 1.3.2

package/common/BaseLoupeDeckHandler.mjs

@@ -219,7 +219,7 @@ export class BaseLoupeDeckHandler {
     const self = this
 
     // Register callback on monitored item change:
-    opcuainterface.on("monitored item changed",(buttonID,nodeid,val) => { self.buttonStateChanged(buttonID,nodeid,val) })
+    opcuainterface.on("monitored item changed",(buttonID,attribute,nodeid,val) => { self.buttonStateChanged(buttonID,attribute,nodeid,val) })
     profileEmitter.on("profileChanged",(profileID) => { self.activateProfile(profileID) })
     profileEmitter.on("brightnessChanged",(brightness) => { self.changeBrightness(brightness) })
     profileEmitter.on("vibrate",(pattern) => { self.vibrate(pattern) })
@@ -364,14 +364,14 @@ export class BaseLoupeDeckHandler {
   /**
    * Handler for StateChanged through OPC/UA Interface - only connected with touch-buttons on center field (yet)
    */
-  async buttonStateChanged(buttonID,nodeid,val) {
+  async buttonStateChanged(buttonID,attribute,nodeid,val) {
     let ok = false
     this.screenUpdate["center"] = true
     this.screenUpdate["left"] = true
     this.screenUpdate["right"] = true
 
-    ok = await this.screens.center.changed(buttonID,nodeid,val)
-    ok = await this.knobs.changed(buttonID,nodeid,val)
+    ok = await this.screens.center.buttonStateChanged(buttonID,attribute,nodeid,val)
+    ok = await this.knobs.buttonStateChanged(buttonID,attribute,nodeid,val)
     
     //await this.updateScreens()
     return ok

package/common/ButtonField.mjs

@@ -97,8 +97,13 @@ export class ButtonField {
       for (let i = 0; i < this.#keys.length; i++) {
         let key = this.#keys[i]
         if (!isNaN(key)) { key = parseInt(key, 10) }
+        // Ignore for myself (active element of the group)
         if (id === key) { continue }
-        if (this.#buttons[key].group === this.#buttons[id].group) {
+        let toggleGroup = this.#buttons[id].getGroup()
+        // Ignore empty groups
+        if (toggleGroup === undefined || toggleGroup == "" ) { continue }
+        // Switch all other elements of the same group off:
+        if (this.#buttons[key].getGroup() === toggleGroup) {
           this.#buttons[key].setState(0)
         }
       }
@@ -115,10 +120,12 @@ export class ButtonField {
    * @param {*} nodeid 
    * @param {*} val 
    */
-  async changed(buttonID,nodeid,val){
+  async buttonStateChanged(changedButtonID,attribute,nodeid,val){
+    // todo: filter for buttonID
     for (let i = 0; i < this.#keys.length; i++) {
-      let bID = this.#keys[i]
-      await this.#buttons[bID].changed(i,nodeid,val)
+      let buttonID = this.#keys[i]
+      if (changedButtonID == buttonID)
+        await this.#buttons[buttonID].buttonStateChanged(i,attribute,nodeid,val)
     } 
   }
 

package/common/button.mjs

@@ -20,6 +20,7 @@ export class Button {
   //#data
   #index = 0
   #enforcedIndex = -1
+  #enforcedBlink = false
   #event
   #keys
   #states
@@ -38,6 +39,7 @@ export class Button {
     this.id = id
     this.#index = 0
     this.#enforcedIndex = -1
+    this.#enforcedBlink = false
 
     this.#profile = profile
     this.#params = {
@@ -144,6 +146,14 @@ export class Button {
     this.#index = index
   }
 
+  /**
+   * 
+   * @returns Group attribute of the current button
+   */
+  getGroup() {
+    return this.#params.group
+  }
+
   /**
    * Draw a physical button (color in RGBA format) on a device
    * @param {*} device 
@@ -194,7 +204,7 @@ export class Button {
     let color = params.color
     let textColor = params.textColor
 
-    if (params.blink && this.#counter % 2 == 0) {
+    if ((params.blink || this.#enforcedBlink)  && this.#counter % 2 == 0) {
       // If blink is set, we switch textcolor and background color:
       color = params.textColor
       textColor = params.color
@@ -370,28 +380,32 @@ export class Button {
    * @param {*} val : the current value of the given nodeid
    * @returns 
    */
-  async changed(buttonID, nodeid, val) {
-    // Only handle updates within the same group identified by nodeid
-    if (nodeid !== this.#params.nodeid) {
-      return
-    }
-
-    this.#index = 0;
-    this.#enforcedIndex = -1;
-    for (let i = 0; i < this.#keys.length; i++) {
-      let stateStr = this.#keys[i].toString()
-      let valStr = val.toString()
-      // check if the state-name is same as the value we get from outside:
-      if (valStr == stateStr) {
-        if (i !== this.#index) {
-          console.info("Changed index", this.id, nodeid, val, i)
-          this.#index = i;
-          console.info("enforce State index", this.id, nodeid, val, i)
-          this.#enforcedIndex = this.#index;
+  async buttonStateChanged(buttonID, attribute, nodeid, val) {
+
+    //
+    if (attribute == "nodeid" && nodeid == this.#params.nodeid) {
+      this.#index = 0;
+      this.#enforcedIndex = -1;
+      for (let i = 0; i < this.#keys.length; i++) {
+        let stateStr = this.#keys[i].toString()
+        let valStr = val.toString()
+        // check if the state-name is same as the value we get from outside:
+        if (valStr == stateStr) {
+          if (i !== this.#index) {
+            console.info("Changed index", this.id, nodeid, val, i)
+            this.#index = i;
+            console.info("enforce State index", this.id, nodeid, val, i)
+            this.#enforcedIndex = this.#index;
+          }
+          break;
         }
-        break;
       }
     }
+
+    if (attribute == "blink") {
+          console.info("Changed blink", buttonID, nodeid, val)
+        this.#enforcedBlink = val;      
+    }
   }
 
   /**
@@ -475,23 +489,27 @@ export class Button {
       profileEmitter.emit("profileChanged", params.profile)
     }
 
-    if (params.brightness !== undefined) {
+    if (params.brightness !== undefined && params.brightness !== '') {
+      // If brightness is set, we emit a brightnessChanged event with the given params
+      // This is used to change the brightness of the device
       profileEmitter.emit("brightnessChanged", params.brightness)
     }
 
-    if (params.vibrate !== undefined) {
+    if (params.vibrate !== undefined && params.vibrate !== '' && params.vibrate !== false) {
+      // If vibrate is set, we emit a vibrate event with the given params
+      // This is used to trigger a vibration on the device
       profileEmitter.emit("vibrate", params.vibrate)
     }
 
     let res = ''
     if ('cmd' in params && shellinterface) {
-        res = await shellinterface.call(params.cmd, params)
+      res = await shellinterface.call(params.cmd, params)
     }
     if ('http' in params && httpinterface) {
-        res = await httpinterface.call(params.http, params)
+      res = await httpinterface.call(params.http, params)
     }
     if ('opcua' in params && opcuainterface) {
-        res = await opcuainterface.call(params.opcua, params)
+      res = await opcuainterface.call(params.opcua, params)
     }
 
     return res

package/interfaces/opcuaif.mjs

@@ -22,12 +22,14 @@ export class OPCUAIf extends BaseIf {
     #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.
@@ -44,13 +46,13 @@ export class OPCUAIf extends BaseIf {
             this.#endpointurl = this.formatString(options.endpointurl, options)
             if (options.publishingInterval)
                 this.#publishingInterval = options.publishingInterval
-            else{
+            else {
                 this.#publishingInterval = 250;
                 this.LogInfo(`OPCUAIf init using default publishingInterval: ${this.#publishingInterval}ms\n`);
             }
             if (options.samplingInterval)
                 this.#samplingInterval = options.samplingInterval
-            else{
+            else {
                 this.#samplingInterval = 100;
                 this.LogInfo(`OPCUAIf init using default samplingInterval: ${this.#samplingInterval}ms\n`);
             }
@@ -62,55 +64,65 @@ export class OPCUAIf extends BaseIf {
             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++) {
+            for (let f = 0; f < fields.length; f++) {
                 let field = fields[f]
-                const keys = Object.keys(field)
+                const buttonNames = Object.keys(field)
 
                 // Iterate over buttons:
-                for (let i = 0; i < keys.length; i++) {
-                    const key = keys[i]
-                    const elem = field[key]
-                    options["key"] = key        // we have to know the key of the button
+                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 && elem.params.nodeid) {
-                        let formattedNodeId = this.formatString(elem.params.nodeid, options)
-                        let monitoredItemId = await this.Subscribe(formattedNodeId)
-                        if (monitoredItemId === undefined) {
-                            this.LogError(`OPCUAIf: Error subscribing to node ${formattedNodeId}\n`)
-                            continue
+                    if (elem.params) {
+                        let attributes = ["nodeid", "blink"]
+                        for (let j = 0; j < attributes.length; j++) {
+                            const attribute = attributes[j]
+                            if (attribute in elem.params) {
+                                if (!this.IsNodeID(elem.params[attribute])) {
+                                    continue
+                                }
+
+                                let monitoredItemId = await this.Subscribe(elem.params[attribute], options,attribute)
+                                if (monitoredItemId) {
+                                    this.buttons[monitoredItemId] = {
+                                        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]
+                                if (attribute in state) {
+                                    if (!this.IsNodeID(state[attribute])) {
+                                        continue
+                                    }      
+                                    let monitoredItemId = await this.Subscribe(state[attribute], options,attribute)
+                                    if (monitoredItemId) {
+                                        this.buttons[monitoredItemId] = {
+                                            buttonID: i,
+                                            buttonName: buttonID,
+                                            attribute: attribute
+                                        }
+                                    }
+                                }
+                            }
                         }
-                        console.log("OPCUAIf: Subscribe to",monitoredItemId,formattedNodeId)
-                        this.buttons[monitoredItemId] = i
                     }
-                    await this.monitorStates(elem, options)
                 }
             }
         } catch (error) {
-            this.LogError(`OPCUAIf: Error\n`,error)
-        }
-    }
-
-    /**
-     * Monitor the state OPC/UA node of the given element 
-     * @param {*} elem : Elem Object
-     * @param {*} 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 formattedNodeId = this.formatString(state.opcua, options)
-                let monitoredItemId = await this.Subscribe(formattedNodeId)
-                if (monitoredItemId === undefined) {
-                    this.LogError(`OPCUAIf: Error subscribing State to node ${formattedNodeId}\n`)
-                    continue
-                }
-                console.log("OPCUAIf: Subscribe to",monitoredItemId,formattedNodeId)
-                this.buttons[monitoredItemId] = i
-            }
+            this.LogError(`OPCUAIf: Error\n`, error)
         }
     }
 
@@ -231,7 +243,7 @@ export class OPCUAIf extends BaseIf {
     async Disconnect() {
         if (this.#client) {
             if (this.#session)
-                await this.#client.closeSession(this.#session,true)
+                await this.#client.closeSession(this.#session, true)
             this.#session = undefined
             this.#client = undefined
             this.LogInfo(`OPCUAIf: Disconnected\n`);
@@ -243,10 +255,10 @@ export class OPCUAIf extends BaseIf {
      */
     async Connect(url) {
         let self = this
-        if (this.#client){
+        if (this.#client) {
             await this.Disconnect()
         }
-        
+
         this.#client = OPCUAClient.create({
             applicationName: "NodeOPCUA-Client",
             endpointMustExist: true,
@@ -263,7 +275,7 @@ export class OPCUAIf extends BaseIf {
             defaultSecureTokenLifetime: 20000,
             tokenRenewalInterval: 1000
         });
-    
+
 
         this.#client.on("backoff", (retry, delay) => {
             //if ((retry % 10) == 0)
@@ -321,12 +333,28 @@ export class OPCUAIf extends BaseIf {
         });
 
         this.LogInfo(`OPCUAIf: session created\n`);
-//        this.LogInfo(`OPCUAIf: client\n`);
-//        this.LogInfo(`OPCUAIf: subscription\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.
@@ -334,15 +362,16 @@ export class OPCUAIf extends BaseIf {
      * @param {*} nodeID 
      * @returns 
      */
-    async Subscribe(nodeID) {
+    async Subscribe(unformattedNodeID, options = {},attribute) {
+        // Format the nodeID using the provided options
+        let nodeID = this.formatString(unformattedNodeID, options)
+        
         // install monitored item
-        const keys = Object.keys(this.monitoreditems)
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i]
-            const elem = this.monitoreditems[key]
-            if (elem == nodeID) {
+        const monitoredNodeIdList = Object.values(this.monitoreditems)
+        for (let i = 0; i < monitoredNodeIdList.length; i++) {
+            if (monitoredNodeIdList[i] == nodeID) {
                 // already registered => return itemid
-                return key
+                return this.monitoreditems[i]
             }
         }
 
@@ -357,7 +386,7 @@ export class OPCUAIf extends BaseIf {
         };
 
         if (!this.#sub) {
-            this.LogError(`OPCUAIf: not register monitored items $itemToMonitor\n`);
+            this.LogError(`OPCUAIf: no subscription - don't register monitored items $itemToMonitor\n`);
             return
         }
         const monitoredItem = await this.#sub.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
@@ -365,14 +394,20 @@ export class OPCUAIf extends BaseIf {
         var self = this
         monitoredItem.on("changed", function (dataValue) {
             var nodeId = self.monitoreditems[this.monitoredItemId]
-            var buttonID = self.buttons[this.monitoredItemId]
+            var buttonInfo = self.buttons[this.monitoredItemId]
             // store the type of a nodeid in local dictionary
             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.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)
         });
 
+        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`);
+        }
+
         return monitoredItem.monitoredItemId;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loupedeck-commander",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "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.yaml

@@ -159,7 +159,8 @@ knobs:
     states:
       on:
         cmd: echo "{id} {state}"
-        opcua: ns=1;s={simnbr}.Function1
+        opcua: ns=2;s=DRV.AAFHR.compOut.FeldTempGetriebeoel
+        blink: ns=2;s=DRV.AAFHR.compOut.Feststellbremse
   knobTR:
     states:
       on:

package/profile-2.yaml

@@ -31,6 +31,8 @@ touch:
           cmd: echo "{id} {state}"
     "1":
       default: two
+      params:
+        nodeid: ns=2;s=DRV.AAFHR.compOut.FeldTempGetriebeoel
       states:
         off:
           color: "#000099"
@@ -185,7 +187,8 @@ knobs:
     states:
       on:
         cmd: echo "{id} {state}"
-        opcua: ns=2;s=Is{simnbr}.Audio.in.VolumeAccustic
+        opcua: ns=2;s=DRV.AAFHR.compOut.FeldTempGetriebeoel
+        blink: ns=2;s=DRV.AAFHR.compOut.Feststellbremse
     group: ""
   knobTR:
     states: