bt-sensors-plugin-sk 1.1.0-beta.2.2.2 → 1.1.0-beta.2.2.4

package/README.md

@@ -1,5 +1,15 @@
 # Bluetooth Sensors for [Signal K](http://www.signalk.org)
 
+## BETA 2.2.4
+### What's New
+Fix to 2.2.3 scan and connect issues. Added Transport option to Config page. Default is Bluetooth LE (was Auto in 2.2.3). 
+
+## BETA 2.2.3
+### What's New
+Support for [JBD/Jiabaida/Xiaoxiang Battery management systems](https://jiabaida-bms.com/), IBeacon and clone devices courtesy of [Arjen R](https://github.com/ArjenR). 
+
+### What's New for Developers
+Runtime loading of external device modules. See (https://github.com/naugehyde/bt-sensors-plugin-sk/discussions/26) 
 ## BETA 2.2.2
 ### What's New
 Support for Lancol Battery Meters, Kilovault HLX+ smart batteries courtesy of [sdlee1963](https://github.com/sdlee1963) and baseline  support for BTHome devices as well as support for the ShellySBHT003C enviromental sensor courtesy of [Sebastian Haas](https://github.com/sebastianhaas) 

package/index.js

@@ -4,13 +4,14 @@ const path = require('path')
 const packageInfo = require("./package.json")
 
 const {createBluetooth} = require('node-ble')
+const { Variant } = require('dbus-next')
 const {bluetooth, destroy} = createBluetooth()
 
 const BTSensor = require('./BTSensor.js')
 const BLACKLISTED = require('./sensor_classes/BlackListedDevice.js')
 
 class MissingSensor  {
-	
+
 
 	constructor(config){
 		this.Metadatum = BTSensor.Metadatum
@@ -53,8 +54,10 @@ class MissingSensor  {
 	stopListening(){}
 	listen(){}
 }
-module.exports =  function (app) {
-	const adapterID = 'hci0'
+module.exports =   function (app) {
+	var adapterID = 'hci0'
+	
+
 	var deviceConfigs
 	var starts=0
 	var classMap
@@ -66,6 +69,8 @@ module.exports =  function (app) {
 	plugin.name = 'BT Sensors plugin';
 	plugin.description = 'Plugin to communicate with and update paths to BLE Sensors in Signalk';
 
+
+	
 	//Try and load utilities-sk NOTE: should be installed from App Store-- 
 	//But there's a fail safe because I'm a reasonable man.
 
@@ -162,10 +167,19 @@ module.exports =  function (app) {
   	}  
 
 	function loadClassMap() {
-		const _classMap = utilities_sk.loadClasses(path.join(__dirname, 'sensor_classes'))
-		classMap = new Map([..._classMap].filter(([k, v]) => !k.startsWith("_") ))
-		classMap.get('UNKNOWN').classMap=new Map([...classMap].filter(([k, v]) => !v.isSystem )) // share the classMap with Unknown for configuration purposes
-
+		import(app.config.appPath+"/lib/modules.js").then( (modulesjs)=>{
+			const _classMap = utilities_sk.loadClasses(path.join(__dirname, 'sensor_classes'))
+			classMap = new Map([..._classMap].filter(([k, v]) => !k.startsWith("_") ))
+			const { default:defaultExport} = modulesjs
+			const modules = defaultExport.modulesWithKeyword(app.config, "signalk-bt-sensor-class")
+			modules.forEach((module)=>{
+				module.metadata.classFiles.forEach((classFile)=>{
+					const cls = require(module.location+module.module+"/"+classFile);
+					classMap.set(cls.name, cls);
+				})
+			})
+			classMap.get('UNKNOWN').classMap=new Map([...classMap].sort().filter(([k, v]) => !v.isSystem )) // share the classMap with Unknown for configuration purposes
+		})
 	}
 
 	app.debug(`Loading plugin ${packageInfo.version}`)
@@ -180,12 +194,15 @@ module.exports =  function (app) {
 		properties: {
 			adapter: {title: "Bluetooth adapter",
 				type: "string", default: "hci0"},
+			transport: {title: "Transport ",
+					type: "string", enum: ["auto","le","bredr"], default: "le", enumNames:["Auto", "LE-Bluetooth Low Energy", "BR/EDR Bluetooth basic rate/enhanced data rate"]},
 
 			discoveryTimeout: {title: "Default device discovery timeout (in seconds)", 
 				type: "integer", default: 30,
 				minimum: 10,
 				maximum: 3600 
 			},
+			
 			discoveryInterval: {title: "Scan for new devices interval (in seconds-- 0 for no new device scanning)", 
 				type: "integer", 
 				default: 10,
@@ -335,23 +352,41 @@ module.exports =  function (app) {
 		})})
 	}
 	
-	async function startScanner() {
+	async function startScanner(transport) {
 		
 		app.debug("Starting scan...");
-		try{ await adapter.stopDiscovery() } catch(error){}
-		try{ await adapter.startDiscovery() } catch(error){}
+		//Use adapter.helper directly to get around Adapter::startDiscovery()
+		//filter options which can cause issues with Device::Connect() 
+		//turning off Discovery
+		//try {await adapter.startDiscovery()}
+		try{ 
+			if (transport) {
+				app.debug(`Setting Bluetooth transport option to ${transport}`)
+				await adapter.helper.callMethod('SetDiscoveryFilter', {
+					Transport: new Variant('s', transport)
+				  })
+				}
+			await adapter.helper.callMethod('StartDiscovery') 
+		} 
+		catch (error){	
+			app.debug(error)
+		}
+		
 	}
 
 	const sensorMap=new Map()
-	var adapter
 	
 	plugin.started=false
 
 	loadClassMap()
 	var discoveryIntervalID
-
+	var adapter 
+	var adapterPower
 	plugin.start = async function (options, restartPlugin) {
-
+		plugin.started=true
+		
+		var adapterID=options.adapter
+		
 		function getDeviceConfig(mac){
 			return deviceConfigs.find((p)=>p.mac_address==mac) 
 		}	
@@ -381,7 +416,8 @@ module.exports =  function (app) {
 					const msg =`Sensor at ${deviceConfig.mac_address} unavailable. Reason: ${error}`
 					app.debug(msg)
 					app.debug(error)
-					app.setPluginError(msg)
+					if (deviceConfig.active) 
+						app.setPluginError(msg)
 					deviceConfig.sensor=new MissingSensor(deviceConfig)
 					addSensorToList(deviceConfig.sensor) //add sensor to list with known options
 				
@@ -420,25 +456,63 @@ module.exports =  function (app) {
 			discoveryIntervalID = setInterval( findDevices, discoveryInterval*1000, discoveryTimeout)
 		}
 	
-		plugin.started=true
+	
+		if (!adapterID || adapterID=="")
+			adapterID = "hci0"
+		//Check if Adapter has changed since last start()
+		if (adapter) {
+			const n = await adapter.getName()
+			if (n!=adapterID) {
+				adapter.helper.removeAllListeners()
+				adapter=null
+			}
+		}
+		//Connect to adapter
+
+		if (!adapter){
+			app.debug(`Connecting to bluetooth adapter ${adapterID}`);
+
+			adapter = await bluetooth.getAdapter(adapterID)
+
+			//Set up DBUS listener to monitor Powered status of current adapter
+
+			await adapter.helper._prepare()
+			adapter.helper._propsProxy.on('PropertiesChanged', async (iface,changedProps,invalidated) => {
+				if (Object.hasOwn(changedProps,"Powered")){
+					if (changedProps.Powered.value==false) {
+						if (plugin.started){ //only call stop() if plugin is started
+							app.setPluginStatus(`Bluetooth Adapter ${adapterID} turned off. Plugin disabled.`)
+							await plugin.stop()
+							adapterPower=false 
+						}
+					} else { 				
+						if (!adapterPower)	{ //only call start() once
+							adapterPower=true
+							await plugin.start(options,restartPlugin)
+						}
+					}
+				}
+			})
+			if (!await adapter.isPowered()) {
+				app.debug(`Bluetooth Adapter ${adapterID} not powered on.`)
+				app.setPluginError(`Bluetooth Adapter ${adapterID} not powered on.`)
+				adapterPower=false
+				await plugin.stop()
+				return
+			}
+		}
+		adapterPower=true
+	
 		plugin.uiSchema.peripherals['ui:disabled']=false
 		sensorMap.clear()
 		deviceConfigs=options?.peripherals??[]
 
-		
-
 		if (plugin.stopped) {
 			await sleep(5000) //Make sure plugin.stop() completes first			
 						  //plugin.start is called asynchronously for some reason
 						  //and does not wait for plugin.stop to complete
 			plugin.stopped=false
 		}
-		var adapterID=options.adapter
-
-		if (!adapterID || adapterID==="")
-			adapterID = "hci0"
-
-		app.debug(`Connecting to bluetooth adapter ${adapterID}`);
 
 		const activeAdapters = await bluetooth.activeAdapters()
 		plugin.schema.properties.adapter.enum=[]
@@ -450,8 +524,8 @@ module.exports =  function (app) {
 
 		plugin.uiSchema.adapter={'ui:disabled': (activeAdapters.length==1)}
 
-		adapter = await bluetooth.getAdapter(adapterID)
-		await startScanner()
+		
+		await startScanner(options.transport)
 		if (starts>0){
 			app.debug(`Plugin ${packageInfo.version} restarting...`);
 			if (plugin.schema.properties.peripherals.items.dependencies)
@@ -479,6 +553,7 @@ module.exports =  function (app) {
 	plugin.stop =  async function () {
 		app.debug("Stopping plugin")
 		plugin.stopped=true
+		plugin.started=false
 		plugin.uiSchema.peripherals['ui:disabled']=true
 		if ((sensorMap)){
 			plugin.schema.properties.peripherals.items.properties.mac_address.enum=[]

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "bt-sensors-plugin-sk",
-  "version": "1.1.0-beta.2.2.2",
+  "version": "1.1.0-beta.2.2.4",
   "description": "Bluetooth Sensors for Signalk -- support for Victron devices, RuuviTag, Xiaomi, ATC and Inkbird, Ultrasonic wind meters, Mopeka tank readers, Renogy Battery and Solar Controllers, Aranet4 environment sensors, SwitchBot temp and humidity sensors, KilovaultHLXPlus smart batteries, and Govee GVH51xx temp sensors",
   "main": "index.js",
   "dependencies": {
     "dbus-next": "^0.10.2",
-    "node-ble": "^1.12.0",
+    "node-ble": "^1.13.0",
     "int24":"^0.0.1",
     "kaitai-struct": "^0.10.0"
   },

package/sensor_classes/BlackListedDevice.js

@@ -1,31 +1,33 @@
 const BTSensor = require("../BTSensor");
-class BLACKLISTED extends BTSensor{
-    static isSystem = true
-    static async identify(device){
-        const md = await this.getDeviceProp(device,'ManufacturerData')
-        if (md){
-            const keys = Object.keys(md)
-            if (keys.length==1 && keys[0]==0x004C)
-                return this
+class BLACKLISTED extends BTSensor {
+    static isSystem = true;
+    static async identify(device) {
+        const md = await this.getDeviceProp(device, "ManufacturerData");
+        if (md && Object.hasOwn(md, 0x004c)){
+            if (md[0x004c].value.slice(0,2).join() != [0x02, 0x15].join()){ // iBeacons are exempt
+                return this;
+            }
+        return null;
         }
-        return null
     }
-    async init(){
-        await super.init()
-        this.currentProperties.Name= `Unsupported device from ${this.getManufacturer()}`
+
+    async init() {
+        await super.init();
+        this.currentProperties.Name = `Unsupported device from ${this.getManufacturer()}`;
     }
     reasonForBlacklisting() {
-        switch ( this.getManufacturerID()){
-            case (0x004C): return "Randomized MAC address (Apple)"
-            case (0x02e1): return "Device is using VE.Smart" //NOTE: Victron/VictronSensor class 
-                                                             //determines if a device is using VE.Smart
-                                                             //in identify(). If so, identify() returns
-                                                             //BlackListedDevice
-        
-            default: return ""
-            
-        }
+        switch (this.getManufacturerID()) {
+            case 0x004c:
+                return "Randomized MAC address (Apple)";
+            case 0x02e1:
+                return "Device is using VE.Smart"; //NOTE: Victron/VictronSensor class
+            //determines if a device is using VE.Smart
+            //in identify(). If so, identify() returns
+            //BlackListedDevice
 
+            default:
+                return "";
+        }
     }
 }
-module.exports=BLACKLISTED
+module.exports = BLACKLISTED;

package/sensor_classes/IBeacon.js

@@ -0,0 +1,42 @@
+const BTSensor = require("../BTSensor");
+
+class IBeacon extends BTSensor {
+    static isSystem = true;
+
+    static async identify(device) {
+        const md = await this.getDeviceProp(device,'ManufacturerData');
+        if (md && Object.hasOwn(md, 0x004c)) {
+            if (md[0x004c].value.slice(0,2).join() == [0x02, 0x15].join()) {
+            return this
+            }
+        }
+    return null
+    }
+
+    async init() {
+        await super.init();
+        this.initMetadata();
+    }
+
+    initMetadata(){
+        this.addMetadatum('battery','ratio', 'Battery charge state', (buffer)=>{return buffer[6]})
+    }
+
+    propertiesChanged(props){
+        super.propertiesChanged(props);
+        const buff = this.getServiceData("0000356e-0000-1000-8000-00805f9b34fb");
+        if (!buff)
+            throw new Error("Unable to get service data for " + this.getDisplayName());
+        this.emitData("battery", buff);
+    }
+
+    getManufacturer(){
+        return "Apple Inc. or clone";
+    }
+
+    getDescription(){
+        return `${this.getName()} iBeacon from Apple Inc. or a clone`
+    }
+}
+
+module.exports = IBeacon;

package/sensor_classes/JBDBMS.js

@@ -0,0 +1,170 @@
+const BTSensor = require("../BTSensor");
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+class JBDBMS extends BTSensor {
+
+  static TX_RX_SERVICE = "0000ff00-0000-1000-8000-00805f9b34fb"  
+  static NOTIFY_CHAR_UUID = "0000ff01-0000-1000-8000-00805f9b34fb"
+  static WRITE_CHAR_UUID  = "0000ff02-0000-1000-8000-00805f9b34fb"
+  
+  constructor(device,config,gattConfig){
+      super(device,config,gattConfig)
+      this.emitterFunctions=
+                [this.getAndEmitBatteryInfo.bind(this), 
+                this.getAndEmitCellVoltages.bind(this)]
+      
+  }
+  static identify(device){
+    return null
+  }
+  jbdCommand(command) {
+    return [0xDD, 0xA5, command, 0x00, 0xFF, 0xFF - (command - 1), 0x77]
+  }
+
+  async sendReadFunctionRequest( command ){    
+    return await this.txChar.writeValueWithResponse(Buffer.from(this.jbdCommand(command)))
+
+}
+  async init(){
+      await super.init()
+      this.addMetadatum('voltage', 'V', 'Total battery voltage', 
+        (buffer)=>{return buffer.readUInt16BE(4) / 100})
+      this.addMetadatum('current',  'A',  'Current flow',
+        (buffer)=>{return buffer.readInt16BE(6) / 100} )
+      this.addMetadatum('remainingCapacity', 'Ah',  'Remaining battery capacity', 
+        (buffer)=>{return buffer.readUInt16BE(8) / 100} )
+      this.addMetadatum('capacity', 'Ah',  'Battery capacity', 
+        (buffer)=>{return buffer.readUInt16BE(10) / 100} )
+      this.addMetadatum('cycles', '', 'cycles',
+        (buffer)=>{return buffer.readUInt16BE(12)} )
+      this.addMetadatum('protectionStatus', '', 'Protection Status',
+          (buffer)=>{return buffer.readUInt16BE(20)} )
+        
+      this.addMetadatum('SOC', 'ratio', 'State of Charge',
+        (buffer)=>{return buffer.readUInt8(23)/100} )
+      
+      this.addMetadatum('FET', '', 'FET Control',
+          (buffer)=>{return buffer.readUInt8(24)} )
+  
+      await this.device.connect()
+      await this.initCharacteristics()
+      const cellsAndTemps = await this.getNumberOfCellsAndTemps()
+      this.numberOfCells=cellsAndTemps.cells
+      this.numberOfTemps=cellsAndTemps.temps
+
+      for (let i=0; i<this.numberOfTemps; i++){
+        this.addMetadatum(`temp${i}`, 'K', `Temperature${i+1} reading`,
+          (buffer)=>{
+            return buffer.readUInt16BE(27+(i*2))/10
+          })
+      }
+      
+      for (let i=0; i<this.numberOfCells; i++){
+        this.addMetadatum(`cell${i}Voltage`, 'V', `Cell ${i+1} voltage`,
+          (buffer)=>{return buffer.readUInt16BE((4+(i*2)))/1000} )
+        this.addMetadatum(`cell${i}Balance`, 'V', `Cell ${i+1} balance` )
+      }
+
+
+    }
+  hasGATT(){
+    return true
+  }
+  initCharacteristics(){ 
+    return new Promise((resolve,reject )=>{ this.device.connect().then(async ()=>{ 
+      const gattServer = await this.device.gatt()
+      const txRxService= await gattServer.getPrimaryService(this.constructor.TX_RX_SERVICE)
+      this.rxChar = await txRxService.getCharacteristic(this.constructor.NOTIFY_CHAR_UUID)
+      this.txChar = await txRxService.getCharacteristic(this.constructor.WRITE_CHAR_UUID)
+      await this.rxChar.startNotifications()
+      resolve(this)
+    }) .catch((e)=>{ reject(e.message) }) }) 
+  }
+
+  async initGATTNotifications(){
+    this.intervalID = setInterval(()=>{
+        this.emitGATT()
+    }, 1000*(this?.pollFreq??60) )
+  }
+
+  emitGATT(){
+    this.getAndEmitBatteryInfo()
+    setTimeout(()=>{this.getAndEmitCellVoltages()}, 5000)
+  }
+
+  async getNumberOfCellsAndTemps(){
+    var b = await this.getBuffer(0x3)
+    return {cells:b[25], temps:b[26]}
+  }  
+  
+  getBuffer(command){
+
+    return new Promise( async ( resolve, reject )=>{
+        const r = await this.sendReadFunctionRequest(command)
+        const result = Buffer.alloc(256)
+        var offset = 0
+
+        const timer = setTimeout(() => {
+          clearTimeout(timer)
+          reject(new Error(`Response timed out from JBDBMS device ${this.getName()}. `));
+        }, 30000);
+
+        const valChanged = async (buffer) => {
+          this.debug(buffer)
+          buffer.copy(result,offset)
+          if (buffer[buffer.length-1]==0x77){
+            this.rxChar.removeAllListeners()
+            clearTimeout(timer)
+            resolve(result)
+          }
+          offset+=buffer.length
+        }
+
+
+        this.rxChar.on('valuechanged', valChanged )
+    })
+} 
+
+async initGATTConnection() {
+  return this  
+}
+
+getAndEmitBatteryInfo(){
+  this.getBuffer(0x03).then((buffer)=>{
+    (["current", "voltage", "remainingCapacity", "capacity","cycles", "protectionStatus", "SOC","FET",]).forEach((tag) =>
+      this.emitData( tag, buffer )
+    )
+    for (let i = 0; i<this.numberOfTemps; i++){
+      this.emitData(`temp${i}`,buffer)    
+    }
+    const balances = buffer.readUInt32BE(16)
+
+    for (let i = 0; i<this.numberOfCells; i++){
+      this.emit(`cell${i}Balance`,(1<<i & balances)?1:0)
+    }
+  })
+}
+
+getAndEmitCellVoltages(){
+  this.getBuffer(0x4).then((buffer)=>{
+    for (let i=0; i<this.numberOfCells; i++){
+      this.emitData(`cell${i}Voltage`,buffer)
+  }})
+}
+
+initGATTInterval(){
+  this.initGATTNotifications()
+}
+
+async stopListening(){
+  super.stopListening()
+  this.rxChar.stopNotifications()
+  await this.device.disconnect()
+}
+  
+}
+
+module.exports = JBDBMS;

package/sensor_classes/RenogyBattery.js

@@ -77,8 +77,8 @@ class RenogyBattery extends RenogySensor {
 
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["current", "voltage", "remainingCharge", "capacity"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["current", "voltage", "remainingCharge", "capacity"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })
@@ -87,7 +87,7 @@ class RenogyBattery extends RenogySensor {
     
     getAndEmitCellVoltages(){
         return new Promise( async ( resolve, reject )=>{
-            this.sendReadFunctionRequest(0x1388,0x11)
+            await this.sendReadFunctionRequest(0x1388,0x11)
 
             this.readChar.once('valuechanged', (buffer) => {
                 for (let i = 0; i++ ; i < this.numberOfCells) 
@@ -99,7 +99,7 @@ class RenogyBattery extends RenogySensor {
 
     getAndEmitCellTemperatures(){
         return new Promise( async ( resolve, reject )=>{
-            this.sendReadFunctionRequest(0x1399,0x22)
+            await this.sendReadFunctionRequest(0x1399,0x22)
 
             this.readChar.once('valuechanged', buffer => {
                 for (let i = 0; i++ ; i < this.numberOfCells) 

package/sensor_classes/RenogyInverter.js

@@ -63,8 +63,8 @@ class RenogyInverter extends RenogySensor {
             await this.sendReadFunctionRequest(0xfa0, 0x8)
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["ueiVoltage","ueiCurrent", "voltage", "loadCurrent", "frequency","temperature"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["ueiVoltage","ueiCurrent", "voltage", "loadCurrent", "frequency","temperature"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })
@@ -77,8 +77,8 @@ class RenogyInverter extends RenogySensor {
             await this.sendReadFunctionRequest(0x10e9, 0x5)
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["solarVoltage","solarCurrent", "solarPower", "solarChargingStatus", "solarChargingPower"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["solarVoltage","solarCurrent", "solarPower", "solarChargingStatus", "solarChargingPower"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })
@@ -91,8 +91,8 @@ class RenogyInverter extends RenogySensor {
             await this.sendReadFunctionRequest(0x113a, 0x2)
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["loadPower", "chargingCurrent"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["loadPower", "chargingCurrent"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })

package/sensor_classes/XiaomiMiBeacon.js

@@ -2,7 +2,6 @@ const BTSensor = require("../BTSensor");
 
 const crypto = require('crypto');
 const util = require('util');
-const { isGeneratorFunction } = require("util/types");
 
 const DEVICE_TYPES = new Map([
     [0x0C3C, { name: "Alarm Clock", model: "CGC1" }],