bt-sensors-plugin-sk 1.2.6-beta-3 → 1.2.6-beta-4

package/BTSensor.js

@@ -75,7 +75,7 @@ function signalQualityPercentQuad(rssi, perfect_rssi=-20, worst_rssi=-85) {
 class BTSensor extends EventEmitter {
  
     static DEFAULTS = require('./plugin_defaults.json');
-    static DistanceManagerSingleton= new DistanceManager({DISTANCE_FIND_LAST_FEW_SAMPLE_TIME_FRAME_MILLIS:60000}) //should be a singleton
+    static DistanceManagerSingleton= new DistanceManager({DISTANCE_FIND_LAST_FEW_SAMPLE_TIME_FRAME_MILLIS:60000}) 
 
     static IsRoaming = false;
 
@@ -255,6 +255,36 @@ class BTSensor extends EventEmitter {
 
     //END static identity functions
 
+    _debugLog=[]
+    _errorLog=[]
+
+    getErrorLog(){
+        return this._errorLog
+    }
+    getDebugLog(){
+        return this._debugLog
+    }
+
+    debug(message){
+        if (this._app)
+            this._app.debug(message)
+        else
+            console.log(message)
+        this._debugLog.push({timestamp:Date.now(), message:message})
+    }
+
+    setError(message){
+        if (this._app){
+            this._app.debug(message)
+            this._app.setPluginError(message)
+        }
+        else
+            console.log(message)
+
+        this._errorLog.push({timestamp:Date.now(), message:message})
+        this.setState("ERROR")
+    }
+
     //Instance Initialization functions
     /**
      * 
@@ -264,6 +294,7 @@ class BTSensor extends EventEmitter {
      *  
      */
 
+
     async initSchema(){
         this._schema = {
             type: "object",
@@ -337,26 +368,50 @@ class BTSensor extends EventEmitter {
             try {
                 this.activateGATT()
             } catch (e) {
-                this.debug(`GATT services unavailable for ${this.getName()}. Reason: ${e}`)
-                this._state="ERROR"
+                this.setError(`GATT services unavailable for ${this.getName()}. Reason: ${e}`)
                 return
             }
         }
-        this._state="ACTIVE"
+        this.setState("ACTIVE")
         this._propertiesChanged(this.currentProperties)
 
     }
 
-    activateGATT(){
-        this.initGATTConnection().then(async ()=>{
+    async getGATTServer(){
+        if (!this._gattServer) 
+            this._gattServer = await this.device.gatt()
+        return this._gattServer
+    }
+    async activateGATT(isReconnecting=false){
+        try{
+            await this.initGATTConnection(isReconnecting)
             await 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}`)
-        })
+        }
+        catch(e) {
+            this.debug(`Unable to activate GATT connection for ${this.getName()} (${this.getMacAddress()}): ${e}`)
+        }
+    }
+
+    async deactivateGATT(){
+        if (this.device) {
+            this.debug(`(${this.getName()}) disconnecting from GATT server`)
+            if (this._gattServer) { //getGATTServer() was called which calls node-ble's Device::gatt() which needs cleaning up after
+            (await this._gattServer.services()).forEach(async (uuid) => {
+                await this._gattServer.getPrimaryService(uuid).then(async (service) => {
+                (await service.characteristics()).forEach(async (uuid) => {
+                    (await service.getCharacteristic(uuid)).helper.removeListeners();
+                });
+                service.helper.removeListeners();
+                });
+                this._gattServer.helper.removeListeners();
+            });        
+            }
+          await this.device.disconnect()  
+        }
     }
 
     /**
@@ -451,8 +506,8 @@ class BTSensor extends EventEmitter {
     * see: VictronBatteryMonitor for an example
     */ 
 
-    initGATTConnection(){
-        throw new Error("::initGATTConnection() should be implemented by the BTSensor subclass")
+    async initGATTConnection(isReconnecting=false, retries=5, retryInterval=3){
+        await this.connectDevice(isReconnecting,retries, retryInterval);
     }
     /**
     * Subclasses providing GATT support should override this method  
@@ -462,11 +517,36 @@ class BTSensor extends EventEmitter {
     * 
     * see: VictronBatteryMonitor for an example
     */ 
-    initGATTNotifications(){
+    async initGATTNotifications(){
         throw new Error("::initGATTNotifications() should be implemented by the BTSensor subclass")
     }
 
-    deviceConnect(reconnect=false) {
+    isConnected(){
+        return this?._connected??false
+    }
+    async connectDevice( isReconnecting, retries=5, retryInterval=3){
+        for (let attempts = 0; attempts<retries; attempts++) {
+            try 
+            { 
+                this.debug( `(${this.getName()}) Trying to connect (attempt # ${attempts +1}) to Bluetooth device.` );
+                await this.deviceConnect(isReconnecting);
+                return this.device
+            }
+
+            catch (e){
+                if (attempts==retries)
+                    throw new Error (`(${this.getName}) Unable to connect to Bluetooth device after ${attempts} attempts`)
+                this.debug(`(${this.getName()}) Error connecting to device. Retrying... `);
+                await new Promise((r) => setTimeout(r, retryInterval*1000));
+
+            }
+        }
+    }
+    setConnected(state){
+        this._connected=state
+        this.emit("connected", this._connected)
+    }
+    deviceConnect(isReconnecting=false, autoReconnect=false) {
 
      
         return connectQueue.enqueue( async ()=>{
@@ -474,33 +554,50 @@ class BTSensor extends EventEmitter {
             await this.device.helper.callMethod('Connect')
 
             this.debug(`Connected to ${this.getName()}`)
-            if (!reconnect) {
-                this.device.helper.on('PropertiesChanged',  (propertiesChanged) => {
-                    if ('Connected' in propertiesChanged) {
-                        const { value } = propertiesChanged.Connected
-                        if (value) {
-                            this.device.emit('connect', { connected: true })
-                        } else {
-                            this.device.emit('disconnect', { connected: false })
-                        }
+            if (!isReconnecting) {
+              this.device.helper.on(
+                "PropertiesChanged",
+                (propertiesChanged) => {
+                  if ("Connected" in propertiesChanged) {
+                    const { value } = propertiesChanged.Connected;
+                    if (value) {
+                      this._connected = true;
+                      this.device.emit("connect", { connected: true });
+                    } else {
+                      this._connected = false;
+                      this.device.emit("disconnect", { connected: false });
                     }
-                })
-                this.device.on("disconnect", ()=>{
-                        if (this.isActive()) {
-                        this.debug(`Device disconnected. Attempting to reconnect to ${this.getName()}`)  
-                            try {        
-                            this.deviceConnect(true).then(()=>{
-                                this.debug(`Device reconnected -- ${this.getName()}`)  
-                            })
-                            }
-                            catch (e) {
-                                this.setPluginError( `Error while reconnecting to ${this.getName()}: ${e.message}`)
-                                this.debug( `Error while reconnecting to ${this.getName()}: ${e.message}`)
-                                this.debug(e)
-                            }
-                        }
-                    })     
+                  }
+                }
+              );
+              if (autoReconnect){
+                this.device.on("disconnect", async () => {
+                    this._connected = false;
+                    if (this.isActive()) {
+                    this.debug(
+                        `Device disconnected. Attempting to reconnect to ${this.getName()}`
+                    );
+                    try {
+                        await this.deactivateGATT();
+                        await this.activateGATT(true);
+                        this.debug(`(${this.getName()}) Device reconnected.`);
+                    } catch (e) {
+                        this.setError(
+                        `Error while reconnecting to ${this.getName()}: ${
+                            e.message
+                        }`
+                        );
+                        this.debug(
+                        `Error while reconnecting to ${this.getName()}: ${
+                            e.message
+                        }`
+                        );
+                        this.debug(e);
+                    }
+                    }
+                });
                 }
+            }
 
             try {
 
@@ -517,9 +614,10 @@ class BTSensor extends EventEmitter {
                     You know, the little things.
                 */
                 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('SetDiscoveryFilter', {
+                //    Transport: new Variant('s', this._adapter?._transport??"le")
+                //})
                 await this._adapter.helper.callMethod('StartDiscovery')   
                 
             } catch (e){
@@ -542,22 +640,21 @@ class BTSensor extends EventEmitter {
 
     initGATTInterval(){
         this.device.disconnect().then(()=>{
-            this.initPropertiesChanged()
-            this.intervalID = setInterval( () => {
-                this.initGATTConnection().then(async ()=>{
+            this.intervalID = setInterval( async () => {
+                try {
+                    await this.initGATTConnection()
                     await this.emitGATT()
-                    this.device.disconnect()
-                        .then(()=>
-                            this.initPropertiesChanged()
-                        )
-                        .catch((e)=>{
-                            this.debug(`Error disconnecting from ${this.getName()}: ${e.message}`)
-                        })
-                })
-                .catch((error)=>{
+                }
+                catch(error) {
                     this.debug(error)
                     throw new Error(`unable to emit values for device ${this.getName()}:${error}`)
-                })
+                }
+                finally{ 
+                    this.deactivateGATT().catch(
+                        (e)=>{
+                            this.debug(`(${this.getName()}) Error deactivating GATT Connection: ${e.message}`)
+                    })
+                }
             }
             , this.pollFreq*1000)
         })
@@ -721,6 +818,10 @@ class BTSensor extends EventEmitter {
     getState(){
         return this._state
     }
+    setState(state){
+        this._state = state
+        this.emit("state",this._state)
+    }
 
     getDomain(){
         return this.constructor.Domain
@@ -824,14 +925,13 @@ class BTSensor extends EventEmitter {
         this.currentProperties = await this.constructor.getDeviceProps(this.device)
         if (this.usingGATT()){
             try {
-                this.activateGATT()
+                await this.activateGATT(true)
             } catch (e) {
-                this.debug(`GATT services unavailable for ${this.getName()}. Reason: ${e}`)
-                this._state="ERROR"
+                this.setError(`GATT services unavailable for ${this.getName()}. Reason: ${e}`)
                 return
             }
         }
-        this._state="ACTIVE"
+        this.setState("ACTIVE")
         this._propertiesChanged(this.currentProperties)
     }
 
@@ -863,9 +963,12 @@ class BTSensor extends EventEmitter {
         this.device.helper.removeListeners()
  
         if (this.intervalID){
+            this.debug(`${this.getName()}::stopListening called clearInterval()`)
             clearInterval(this.intervalID)
         }
-        this._state="ASLEEP"
+        if( this.usingGATT() )
+            await this.deactivateGATT()
+        this.setState("ASLEEP")
     }
     //END Sensor listen-to-changes functions
     
@@ -890,7 +993,7 @@ class BTSensor extends EventEmitter {
             const path = config.paths[tag]
             if (!(path===undefined)) {
                 const preparedPath  =
-                this.app.handleMessage(id, 
+                this._app.handleMessage(id, 
                 {
                 updates: 
                     [{ meta: [{path:  this.preparePath(path), value: { units: pathMeta?.unit }}]}]
@@ -908,7 +1011,7 @@ class BTSensor extends EventEmitter {
                 let preparedPath =  this.preparePath(path)
                 this.on(tag, (val)=>{
 					if (pathMeta.notify){
-						this.app.notify(tag, val, id )
+						this._app.notify(tag, val, id )
 					} else {
 						this.updatePath(preparedPath,val, id, source)
 					}
@@ -917,7 +1020,7 @@ class BTSensor extends EventEmitter {
 		})
 	}
 	updatePath(path, val, id, source){
-		this.app.handleMessage(id, {updates: [ { $source: source, values: [ { path: path, value: val }] } ] })
+		this._app.handleMessage(id, {updates: [ { $source: source, values: [ { path: path, value: val }] } ] })
   	}  
     elapsedTimeSinceLastContact(){
         return (Date.now()-this?._lastContact??Date.now())/1000

package/README.md

@@ -1,6 +1,11 @@
 # Bluetooth Sensors for [Signal K](http://www.signalk.org) 
 
 ## WHAT'S NEW  
+# Version 1.2.6-beta-4
+
+- Improved reconnect logic for connected devices
+- Error display in config (preliminary effort)  
+- JikongBMS support (aka JKBMS)
 
 # Version 1.2.6-beta-3
 

package/classLoader.js

@@ -10,8 +10,15 @@ const semver = require('semver')
         
             classFiles.forEach( (file) => {
                 const filePath = path.join(dir, file);
-                const cls = require (filePath)
-                classMap.set(cls.name, cls);
+                try{
+                    const cls = require (filePath)
+                    classMap.set(cls.name, cls);
+                } 
+                catch (e) {
+                    console.log(`Unable to load class (${cls?.name}): ${e.message}`)
+                    console.log(e)
+                }
+
             })
             return classMap
         }

package/development/FakeBTDevice.js

@@ -26,10 +26,13 @@ export class FakeGATTCharacteristic extends EventEmitter{
     this.values=values
     this.interval = interval
   }
+  writeValueWithoutResponse(buffer){
+    //do nothing for now
+  }
   startNotifications(){
       this.intervalID=setInterval(()=>{
       if (this.values.length>0){
-        this.emit("valuechanged",Buffer.from(this.values[this.valueIndex++],"hex") )
+        this.emit("valuechanged",Buffer.from((this.values[this.valueIndex++]).replaceAll(" ",""),"hex") )
         if (this.valueIndex>=this.values.length)
           this.valueIndex=0
       }