bt-sensors-plugin-sk 1.1.1 → 1.2.0-beta.0.0.10

package/BTSensor.js

@@ -1,6 +1,7 @@
 const { Variant } = require('dbus-next');
 const { log } = require('node:console');
 const EventEmitter = require('node:events');
+const AutoQueue =  require("./Queue.js")
 
 /** 
  * @author Andrew Gerngross <oh.that.andy@gmail.com>
@@ -10,7 +11,9 @@ const EventEmitter = require('node:events');
  * {@link module:node-ble}
  */
 
-const BTCompanies = require('./bt_co.json')
+const BTCompanies = require('./bt_co.json');
+const connectQueue = new AutoQueue()
+
 /**
  * @global A map of company names keyed by their Bluetooth ID
  * {@link ./sensor_classes/bt_co.json} file derived from bluetooth-sig source:
@@ -51,6 +54,38 @@ function signalQualityPercentQuad(rssi, perfect_rssi=-20, worst_rssi=-85) {
     }
     return Math.ceil(signal_quality);
 }
+function preparePath(obj, str) {
+    const regex = /\{([^}]+)\}/g;
+    let match;
+    let resultString = "";
+    let lastIndex = 0;
+  
+    while ((match = regex.exec(str)) !== null) {
+      const fullMatch = match[0];
+      const keyToAccess = match[1].trim();
+  
+      // Append the text before the current curly braces
+      resultString += str.substring(lastIndex, match.index);
+      lastIndex = regex.lastIndex;
+  
+      try {
+        let evalResult = obj[keyToAccess];
+        if (typeof evalResult === 'function'){
+            evalResult= evalResult.call(obj)
+        }
+
+        resultString += evalResult !== undefined ? evalResult : `${keyToAccess}_value_undefined`;
+      } catch (error) {
+        console.error(`Error accessing key '${keyToAccess}':`, error);
+        resultString += fullMatch; // Keep the original curly braces on error
+      }
+    }
+  
+    // Append any remaining text after the last curly braces
+    resultString += str.substring(lastIndex);
+  
+    return resultString || str; // Return original string if no replacements were made
+  }
 
 /**
  * @classdesc Class that all sensor classes should inherit from. Sensor subclasses 
@@ -65,8 +100,9 @@ function signalQualityPercentQuad(rssi, perfect_rssi=-20, worst_rssi=-85) {
  */
 
 class BTSensor extends EventEmitter {
-    static metadata=new Map()
-
+ 
+    static DEFAULTS = require('./plugin_defaults.json');
+    
     /**
      * 
      * @param {module:node-ble/Device} device 
@@ -77,13 +113,11 @@ class BTSensor extends EventEmitter {
         super()
   
         this.device=device
-        this.name = config?.name
-  
-        this.useGATT = gattConfig?.useGATT
-        this.pollFreq = gattConfig?.pollFreq
-        
-        this.Metadatum = this.constructor.Metadatum
-        this.metadata = new Map()
+
+        Object.assign(this,config)
+        Object.assign(this,gattConfig)
+    
+        this._state = null
     }
     /**
      * @function _test Test sensor parsing
@@ -133,7 +167,7 @@ class BTSensor extends EventEmitter {
         var b = Buffer.from(data.replaceAll(" ",""),"hex")
         const d = new this(null,config)
         d.initMetadata() 
-        d.getPathMetadata().forEach((datum,tag)=>{
+        Object.keys(d.getPaths()).forEach((tag)=>{
                 d.on(tag,(v)=>console.log(`${tag}=${v}`))
         })
         if (key) {
@@ -145,38 +179,7 @@ class BTSensor extends EventEmitter {
         d.removeAllListeners()
     
     }
-    static Metadatum = 
-    /**
-     * @class encapsulates a sensor's metadata 
-     * @todo refactor and/or just plain rethink constructor parameters
-     */
-        class Metadatum{
-        
-            constructor(tag, unit, description, read, gatt=null, type){
-                this.tag = tag
-                this.unit = unit
-                this.description = description
-                this.read = read
-                this.gatt = gatt
-                this.type = type //schema type e.g. 'number'
-           } 
-           /**
-            * 
-            * @returns A JSON object passed by plugin to the plugin's schema 
-            *          dynamically updated at runtime upon discovery and interrogation
-            *          of the device
-            */
-            asJSONSchema(){
-                return {
-                    type:this?.type??'string', 
-                    title: this?.description,
-                    unit: this?.unit,
-                    enum: this?.enum,
-                    default: this?.default
-                }
-            }
-        }  
-
+    
     //static utility Functions
     /**
      * 
@@ -274,42 +277,157 @@ class BTSensor extends EventEmitter {
      *  
      */
 
-    async init(){
+    initSchema(){
+        this._schema = {
+            properties:{
+                active: {title: "Active", type: "boolean", default: true },
+                discoveryTimeout: {title: "Device discovery timeout (in seconds)", 
+                    type: "integer", default:30,
+                    minimum: 10,
+                    maximum: 600 },
+            
+                params:{
+                    title:`Device parameters`,
+                    description: this.getDescription(),
+                    type:"object",
+                    properties:{}
+                },
+                paths:{
+                    title:"Signalk Paths",
+                    description: `Signalk paths to be updated when ${this.getName()}'s values change`,
+                    type:"object",
+                    properties:{}
+                }
+            }
+        }
+
+		if (this.hasGATT()){
+
+			this._schema.properties.gattParams={
+				title:`GATT Specific device parameters`,
+				description: this.getGATTDescription(),
+				type:"object",
+				properties:{
+                    useGATT: {title: "Use GATT connection", type: "boolean", default: false },
+                    pollFreq: { type: "number", title: "Polling frequency in seconds"}
+                }
+			}
+		}
+
+
         //create the 'name' parameter
-        var md = this.addMetadatum("name", "string","Name of sensor" )
-        md.isParam=true
+        this.addDefaultParam("name")
+            .default=this?.currentProperties?.Name
+
+        //create the 'location' parameter
+
+        //this.addDefaultParam("location")
+
         //create the 'RSSI' parameter 
+        this.addDefaultPath("RSSI","sensors.RSSI")
+        this.getPath("RSSI").read=()=>{return this.getRSSI()}
+        this.getPath("RSSI").read.bind(this)
+
+    }
+    async init(){
         this.currentProperties = await this.constructor.getDeviceProps(this.device)
-        this.addMetadatum("RSSI","db","Signal strength in db")
-        this.getMetadatum("RSSI").default=`sensors.${this.getMacAddress().replaceAll(':', '')}.rssi`
-        this.getMetadatum("RSSI").read=()=>{return this.getRSSI()}
-        this.getMetadatum("RSSI").read.bind(this)
-        //create GATT params (iff sensor is GATT-ish)
-        if (this.hasGATT()) {
-            md = this.addMetadatum("useGATT", "boolean", "Use GATT connection")
-            md.type="boolean"
-            md.isParam=true
-            md.isGATT=true
-
-            md = this.addMetadatum("pollFreq", "s", "Polling frequency in seconds")
-            md.type="number"
-            md.isParam=true
-            md.isGATT=true
+        this.initSchema()
+
+        this.initListen()
+    }
+
+    initListen(){
+        Promise.resolve(this.listen())
+    }
+    activate(config, plugin){
+        if (config.paths){
+            this.createPaths(config,plugin.id)
+            this.initPaths(config,plugin.id)
+            this.debug(`Paths activated for ${this.getDisplayName()}`);
         }
+        if (this.usingGATT()){
+            try {
+            this.activateGATT()
+            } catch (e) {
+                this.debug(`GATT services unavailable for ${this.getName()}. Reason: ${e}`)
+                this._state="ERROR"
+                return
+            }
+        }
+        this._state="ACTIVE"
+    }
+
+    activateGATT(){
+        this.initGATTConnection().then(async ()=>{
+            this.emitGATT()
+            if (this.pollFreq){
+                this.initGATTInterval()
+            }
+            else 
+                await this.initGATTNotifications()
+        }).catch((e)=>{
+            this.app.debug(`Unable to activate GATT connection for ${this.getName()} (${this.getMacAddress()}): ${e}`)
+        })
     }
 
     /**
      * Add a metadatum instance to the sensor instance
      *  
-     * @param {String} tag 
+     * @param {String} tag
      * @param  {...any} args 
      * @returns {this.Metadatum} the new metadatum instance
      */
 
     addMetadatum(tag, ...args){
-        var metadatum = new this.Metadatum(tag, ...args)
-        this.getMetadata().set(tag, metadatum)
-        return metadatum
+
+        const md = {}
+        if (args[0]) md.unit = args[0]
+        if (args[1]) md.title = args[1]
+        if (args[2]) md.read = args[2]
+        if (args[3]) md.gatt = args[3]
+        if (args[4]) md.type = args[4]
+     
+        return this.addPath(tag,md)
+    }
+
+    addParameter(tag, param){
+
+        if (!param.type)
+            param.type="string"
+
+        this._schema.properties.params.properties[tag]=param
+        return this._schema.properties.params.properties[tag]
+    }
+
+    addPath(tag, path){
+        if (!path.type)
+            path.type="string"
+
+        if (!path.pattern)
+            path.pattern="^(?:[^{}\\s]*\\{[a-zA-Z0-9]+\\}[^{}\\s]*|[^{}\\s]*)$"
+        this._schema.properties.paths.properties[tag]=path
+        return this._schema.properties.paths.properties[tag]
+    }
+   
+    addGATTParameter(tag, param){
+
+        if (!param.type)
+            param.type="string"
+        
+        return this._schema.properties.gattParams.properties[tag]=param
+    }
+
+    addDefaultPath(tag,defaultPath){
+        const path = eval(`BTSensor.DEFAULTS.${defaultPath}`)
+        return this.addPath(tag,Object.assign({}, path))
+    }
+
+    addDefaultParam(tag){        
+        return this.addParameter(tag,Object.assign({}, BTSensor.DEFAULTS.params[tag]))
+    }
+
+    getJSONSchema(){
+        return this._schema
     }
 
     //GATT Initialization functions
@@ -337,6 +455,39 @@ class BTSensor extends EventEmitter {
         throw new Error("::initGATTNotifications() should be implemented by the BTSensor subclass")
     }
 
+    deviceConnect() {
+
+        /* CAUTION: HACK AHEAD 
+
+        Bluez for some cockamamie reason (It's 2025 for chrissake. 
+        BLUETOOTH ISN'T JUST FOR DESKTOPS ANYMORE, BLUEZ DEVS!)
+        SUSPENDS scanning while connected to a device.
+
+        The next line of code gives the scanner a kick in the arse, 
+        starting it up again so, I dunno, another device might be able 
+        to connect and sensor classes could maybe get beacon updates.
+
+        You know, the little things.
+      */
+        return connectQueue.enqueue( async ()=>{
+            this.debug(`Connecting to ${this.getName()}`)
+            await this.device.connect()
+            try {
+
+                await this._adapter.helper.callMethod('StopDiscovery')
+                await this._adapter.helper.callMethod('SetDiscoveryFilter', {
+                    Transport: new Variant('s', this._adapter?._transport??"le")
+                })
+                await this._adapter.helper.callMethod('StartDiscovery')   
+                
+            } catch (e){
+                //probably ignorable error. probably.
+                console.log(e)
+            }
+        })
+    /* END HACK*/
+  }
+
     /**
      * 
      * Subclasses do NOT need to override this function
@@ -376,12 +527,12 @@ class BTSensor extends EventEmitter {
      */
     initPropertiesChanged(){
 
-        this.propertiesChanged.bind(this)
+        this._propertiesChanged.bind(this)
         this.device.helper._prepare()
         this.device.helper.on("PropertiesChanged",
             ((props)=> {
                 try{
-                    this.propertiesChanged(props)
+                    this._propertiesChanged(props)
                 }
                 catch(error){
                     this.debug(`Error occured on ${this.getNameAndAddress()}: ${error?.message??error}`)
@@ -392,30 +543,23 @@ class BTSensor extends EventEmitter {
     //END instance initialization functions
 
     //Metadata functions
-    getMetadata(){
-        if (this.metadata==undefined)
-            this.metadata= new Map(this.constructor.getMetadata())
-        return this.metadata
-    }
 
-    getMetadatum(tag){
-        return this.getMetadata().get(tag)
+    getPath(tag){
+        return this._schema.properties.paths.properties[tag]
     }
 
-    getPathMetadata(){
-        return new Map(
-            [...this.getMetadata().entries()].filter(([key,value]) => !(value?.isParam??false))
-        )
+    getPaths(){
+        return this._schema.properties.paths.properties
     }
-    getParamMetadata(){
-        return new Map(
-            [...this.getMetadata().entries()].filter(([key,value]) => (value?.isParam??false) && !(value?.isGATT??false))
-        )
+    getParams(){
+        return this._schema.properties.params.properties
     }
-    getGATTParamMetadata(){
-        return new Map(
-            [...this.getMetadata().entries()].filter(([key,value]) => (value?.isParam??false) && (value?.isGATT??false))
-        )
+    getParameter(param){
+        return this.getParams()[param]
+    }
+    getGATTParams(){
+        return this._schema.properties.gattParams.properties
+       
     }
     //End metadata functions
 
@@ -429,9 +573,13 @@ class BTSensor extends EventEmitter {
         return `${this.getName()} from ${this.getManufacturer()}`
     }
     getName(){
-        return this?.name??this.currentProperties.Name
-    }
+        const name = this?.name??this.currentProperties.Name
+        return name?name:"Unknown"
 
+    }
+    macAndName(){
+        return `${this.getName().replaceAll(':', '-').replaceAll(" ","_")}-${this.getMacAddress().replaceAll(':', '-')}`
+    }
     getNameAndAddress(){
         return `${this.getName()} at ${this.getMacAddress()}`
     }
@@ -475,6 +623,8 @@ class BTSensor extends EventEmitter {
         else
             return null
     }
+
+ 
     //END Device property functions
 
     //Sensor RSSI state functions
@@ -490,6 +640,13 @@ class BTSensor extends EventEmitter {
         return signalQualityPercentQuad(rssi)
     }
 
+    getState(){
+        return this._state
+    }
+
+    isActive(){
+        return this._state=="ACTIVE"
+    }
     getBars(){
         const ss =  this.getSignalStrength()
         var bars = ""
@@ -532,7 +689,8 @@ class BTSensor extends EventEmitter {
      * @param {*} props which contains ManufacturerData and ServiceData (where the sensor's data resides)
      * set up by BTSensor::initPropertiesChanged()
      */
-    propertiesChanged(props){
+    _propertiesChanged(props){
+        this._lastContact=Date.now()
             
         if (props.RSSI) {
             this.currentProperties.RSSI=this.valueIfVariant(props.RSSI)
@@ -543,8 +701,13 @@ class BTSensor extends EventEmitter {
 
         if (props.ManufacturerData)
             this.currentProperties.ManufacturerData=this.valueIfVariant(props.ManufacturerData)
+        if (this.isActive())
+            this.propertiesChanged(props)
 
     }
+    propertiesChanged(props){
+        //implemented by subclass
+    }
 
    /**
    * 
@@ -555,14 +718,18 @@ class BTSensor extends EventEmitter {
     }
 
     emitData(tag, buffer, ...args){
-        this.emit(tag, this.getMetadatum(tag).read(buffer, ...args))
+        const md = this.getPath(tag)
+        if (md && md.read)
+            this.emit(tag, md.read(buffer, ...args))
+
+        
     }
 
     emitValuesFrom(buffer){
-        this.getMetadata().forEach((datum, tag)=>{
-            if (!(datum.isParam||datum.notify) && datum.read)
-            this.emit(tag, datum.read(buffer))
-        })
+        Object.keys(this.getPaths())
+            .forEach(
+                (tag)=>this.emitData(tag,buffer)
+        )
     }
 
   /**
@@ -576,21 +743,10 @@ class BTSensor extends EventEmitter {
     listen(){
         try{
             this.initPropertiesChanged()       
-            this.propertiesChanged(this.currentProperties)
+            this._propertiesChanged(this.currentProperties)
         } catch(e){
             this.debug(e)
         }
-        if (this.usingGATT()){
-            this.initGATTConnection().then(async ()=>{
-                this.emitGATT()
-                if (this.pollFreq){
-                    this.initGATTInterval()
-                }
-                else 
-                    await this.initGATTNotifications()
-            })
-            .catch((e)=>this.debug(`GATT services unavailable for ${this.getName()}. Reason: ${e}`))
-        }
         return this
     }
 
@@ -601,12 +757,13 @@ class BTSensor extends EventEmitter {
    *  Called automatically by Plugin::plugin.stop()
    */
 
-    stopListening(){
+    async stopListening(){
         this.removeAllListeners()
         this.device.helper.removeListeners()
         if (this.intervalID){
             clearInterval(this.intervalID)
-        }    
+        }
+        this._state="ASLEEP"
     }
     //END Sensor listen-to-changes functions
     
@@ -622,6 +779,45 @@ class BTSensor extends EventEmitter {
         
     }
     //End instance utility functions
+
+     createPaths(config, id){
+//        const source = `${this.getName()} (${id})`
+
+		Object.keys(this.getPaths()).forEach((tag)=>{
+            const pathMeta=this.getPath(tag)
+            const path = config.paths[tag]
+            if (!(path===undefined))
+                this.app.handleMessage(id, 
+                {
+//                $source: source,
+                updates: 
+                    [{ meta: [{path: preparePath(this, path), value: { units: pathMeta?.unit }}]}]
+                })
+        })
+	}
+
+	 initPaths(deviceConfig, id){
+        const source = this.getName()
+		Object.keys(this.getPaths()).forEach((tag)=>{
+            const pathMeta=this.getPath(tag)
+			const path = deviceConfig.paths[tag];
+			if (!(path === undefined)) {
+                this.on(tag, (val)=>{
+					if (pathMeta.notify){
+						this.app.notify(tag, val, id )
+					} else {
+						this.updatePath(preparePath(this,path),val, id, source)
+					}
+                })
+			}
+		})
+	}
+	updatePath(path, val, id, source){
+		this.app.handleMessage(id, {updates: [ { $source: source, values: [ { path: path, value: val }] } ] })
+  	}  
+    elapsedTimeSinceLastContact(){
+        return (Date.now()-this?._lastContact??Date.now())/1000
+    }
 }
 
 module.exports = BTSensor   

package/Queue.js

@@ -0,0 +1,48 @@
+/*
+see: https://stackoverflow.com/questions/53540348/js-async-await-tasks-queue 
+*/
+ class Queue {
+    constructor() { this._items = []; }
+    enqueue(item) { this._items.push(item); }
+    dequeue()     { return this._items.shift(); }
+    get size()    { return this._items.length; }
+  }
+  
+   class AutoQueue extends Queue {
+    constructor() {
+      super();
+      this._pendingPromise = false;
+    }
+  
+    enqueue(action) {
+      return new Promise((resolve, reject) => {
+        super.enqueue({ action, resolve, reject });
+        this.dequeue();
+      });
+    }
+  
+    async dequeue() {
+      if (this._pendingPromise) return false;
+  
+      let item = super.dequeue();
+  
+      if (!item) return false;
+  
+      try {
+        this._pendingPromise = true;
+  
+        let payload = await item.action(this);
+  
+        this._pendingPromise = false;
+        item.resolve(payload);
+      } catch (e) {
+        this._pendingPromise = false;
+        item.reject(e);
+      } finally {
+        this.dequeue();
+      }
+  
+      return true;
+    }
+  }
+  module.exports = AutoQueue