bt-sensors-plugin-sk 1.0.2 → 1.1.0-beta.1

package/index.js

@@ -5,20 +5,58 @@ const {createBluetooth} = require('node-ble')
 const {bluetooth, destroy} = createBluetooth()
 
 const BTSensor = require('./BTSensor.js')
+const BLACKLISTED = require('./sensor_classes/BlackListedDevice.js')
 
-const Device = require('./node_modules/node-ble/src/Device.js')
+class MissingSensor  {
+	
 
-Device.prototype.getUUIDs=async function() {
-	return this.helper.prop('UUIDs')
-}
+	constructor(config){
+		this.Metadatum = BTSensor.Metadatum
+		this.addMetadatum=BTSensor.prototype.addMetadatum
+		this.getPathMetadata = BTSensor.prototype.getPathMetadata
+		this.getParamMetadata = BTSensor.prototype.getParamMetadata
 
+		this.metadata= new Map()
+		var keys = Object.keys(config?.paths??{})
+		this.addMetadatum.bind(this)
+		keys.forEach((key)=>{
+			this.addMetadatum(key, config.paths[key]?.type??'string',  config.paths[key].description )
+		} )
+		keys = Object.keys(config?.params??{})
+		keys.forEach((key)=>{
+			this.addMetadatum(key, config.params[key]?.type??'string',  config.params[key].description ).isParam=true
+			this[key]=config.params[key]
+		})
+		this.mac_address = config.mac_address
+		
+	}
+	canUseGATT(){
+		return false
+	}
+	getMetadata(){
+		return this.metadata
+	}
+	getMacAddress(){
+		return this.mac_address
+	}
+	getDescription(){
+		return ""
+	}
+	getName(){
+		return this?.name??"Unknown device"
+	}	
+	getDisplayName(){
+		return `OUT OF RANGE DEVICE (${this.getName()} ${this.getMacAddress()})`
+	}
+	disconnect(){}
+	connect(){}
+}
 module.exports =  function (app) {
-	const discoveryTimeout = 30
 	const adapterID = 'hci0'
-	
-	var peripherals=[]
+	var deviceConfigs
 	var starts=0
 	var classMap
+	
 	var utilities_sk
 	
 	var plugin = {};
@@ -29,233 +67,403 @@ module.exports =  function (app) {
 	//Try and load utilities-sk NOTE: should be installed from App Store-- 
 	//But there's a fail safe because I'm a reasonable man.
 
-	try{
-		utilities_sk = require('../utilities-sk/utilities.js')
+	utilities_sk = {
+		loadClasses: function(dir, ext='.js')
+		{
+			const classMap = new Map()
+			const classFiles = fs.readdirSync(dir)
+			.filter(file => file.endsWith(ext));
+		
+			classFiles.forEach(file => {
+				const filePath = path.join(dir, file);
+				const cls = require(filePath);
+				classMap.set(cls.name, cls);
+			})
+			return classMap
+		}
 	}
-	catch (error){
-		try {
-			utilities_sk = require('utilities-sk/utilities.js')
-		} catch(error){
-			console.log(`${plugin.id} Plugin utilities-sk not found. Please install.`)
-			utilities_sk = {
-				loadClasses: function(dir, ext='.js')
-				{
-					const classMap = new Map()
-					const classFiles = fs.readdirSync(dir)
-					.filter(file => file.endsWith(ext));
+
+	function sleep(x) {
+		return new Promise((resolve) => {
+		  setTimeout(() => {
+			resolve(x);
+		  }, x);
+		});
+	  }
+	async function instantiateSensor(device,config){
+		try{
+		for (var [clsName, cls] of classMap) {
+			const c = await cls.identify(device)
+			if (c) {
 				
-					classFiles.forEach(file => {
-						const filePath = path.join(dir, file);
-						const cls = require(filePath);
-						classMap.set(cls.name, cls);
-					})
-					return classMap
-				}
-			 }
+				if (c.name.startsWith("_")) continue
+				c.debug=app.debug
+				c.debug.bind(c)
+				const sensor = new c(device,config?.params, config?.gattParams)
+				sensor.debug=app.debug
+				await sensor.init()
+				return sensor
+			}
+		}} catch(error){
+			const msg = `Unable to instantiate ${await BTSensor.getDeviceProp(device,"Address")}: ${error.message} `
+			app.debug(msg)
+			app.debug(error)
+			app.setPluginError(msg)
 		}
+		//if we're here ain't got no class for the device
+		const sensor = new (classMap.get('UNKNOWN'))(device)
+		await sensor.init()
+		return sensor
 	}
-	function createPaths(sensorClass, peripheral){
 
-		for (const tag of sensorClass.metadataTags()) {
-			const path = peripheral[tag]
-			if (!(path===undefined))
-				app.handleMessage(plugin.id, 
-				{
-				updates: 
-					[{ meta: [{path: path, value: { units: sensorClass.unitFor(tag) }}]}]
-				}
-			)
-		}
-  	}
+	function createPaths(config){
+		config.sensor.getMetadata().forEach((metadatum, tag)=>{
+			if ((!(metadatum?.isParam)??false)){ //param metadata is passed to the sensor at 
+												 //create time through the constructor, and isn't a
+												 //a value you want to see in a path 
+				
+				const path = config.paths[tag]
+				if (!(path===undefined))
+					app.handleMessage(plugin.id, 
+					{
+					updates: 
+						[{ meta: [{path: path, value: { units: metadatum?.unit }}]}]
+					})
+			}
+			})
+	}
 
+	function initPaths(deviceConfig){
+		deviceConfig.sensor.getMetadata().forEach((metadatum, tag)=>{
+			const path = deviceConfig.paths[tag];
+			if (!(path === undefined))
+				deviceConfig.sensor.on(tag, (val)=>{
+					if (metadatum.notify){
+						app.notify(	tag, val, plugin.id )
+					} else {
+						updatePath(path,val)
+					}
+			})
+		})
+	}
 	function updatePath(path, val){
 		app.handleMessage(plugin.id, {updates: [ { values: [ {path: path, value: val }] } ] })
   	}  
 
 	function loadClassMap() {
 		classMap = utilities_sk.loadClasses(path.join(__dirname, 'sensor_classes'))
-
 	}
 
 	app.debug('Loading plugin')
 	
-	plugin.uiSchema = {
-		peripherals: {
-		 	  'ui:disabled': true
-		}
-	}
-	
 	plugin.schema = {			
 		type: "object",
-		description: "",
+		description: "NOTE: \n 1) Plugin must be enabled to configure your sensors. \n"+
+		"2) You will have to wait until the scanner has found and connected to your device before seeing your device's config fields and saving the configuration. \n"+
+		"3) To refresh the list of available devices and their configurations, just open and close the config screen by clicking on the arrow symbol in the config's top bar. \n"+
+		"4) If you submit and get errors it may be because the configured devices have not yet all been discovered.",
+		required:["discoveryTimeout", "discoveryInterval"],
 		properties: {
-			adapter: {title: "Bluetooth Adapter", type: "string", enum:[], default:'hci0' },
-			discoveryTimeout: {title: "Initial scan timeout (in seconds)", type: "number",default: 45 },
+			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: 60,
+				minimum: 0,
+				multipleOf: 10
+			 },
 			peripherals:
 				{ type: "array", title: "Sensors", items:{
-					title: "", type: "object", 
+					title: "", type: "object",
+					required:["mac_address", "discoveryTimeout"],
 					properties:{
-						active: {title: "Active", type: "boolean", default: true },
-						mac_address: {title: "Bluetooth Device", enum: [], enumNames:[], type: "string" },
-						BT_class:  {title: "Bluetooth sensor class", type: "string", enum: []},
-						discoveryTimeout: {title: "Discovery timeout (in seconds)", type: "number", default:30},
-					}, dependencies:{BT_class:{oneOf:[]}}
+					active: {title: "Active", type: "boolean", default: true },
+					mac_address: {title: "Bluetooth Sensor",  type: "string" },
+					discoveryTimeout: {title: "Device discovery timeout (in seconds)", 
+						type: "integer", default:30,
+						minimum: 10,
+						maximum: 600 
+					}
+					}
 					
 				}
 			}
 		}
 	}
-	
-	function setDeviceNameInList(device,name){
-		const deviceNamesList = plugin.schema.properties.peripherals.items.properties.
-		mac_address.enumNames
-		const deviceList = plugin.schema.properties.peripherals.items.properties.
+	const UI_SCHEMA =  
+	{ "peripherals": {
+		'ui:disabled': !plugin.started
+ 	}
+	}
+	plugin.uiSchema=UI_SCHEMA
+		
+	function updateSensorDisplayName(sensor){
+		const mac_address =  sensor.getMacAddress()
+		const displayName =  sensor.getDisplayName()
+
+		const mac_addresses_list = plugin.schema.properties.peripherals.items.properties.
 		mac_address.enum
+		const mac_addresses_names = plugin.schema.properties.peripherals.items.properties.
+		mac_address.enumNames
 
-		deviceNamesList[deviceList.indexOf(device)]=`${name} (${device})` 
+		var index = mac_addresses_list.indexOf(mac_address)
+		if (index!=-1)
+			mac_addresses_names[index]= displayName
 	}
 
-	function addDeviceToList( device, name ){
-		const devices = plugin.schema.properties.peripherals.items.properties.
-		mac_address.enum
+	function removeSensorFromList(sensor){
+		const mac_addresses_list = plugin.schema.properties.peripherals.items.properties.mac_address.enum
+		const mac_addresses_names = plugin.schema.properties.peripherals.items.properties.mac_address.enumNames
+		const oneOf = plugin.schema.properties.peripherals.items.dependencies.mac_address.oneOf
+		const mac_address = sensor.getMacAddress()
+		
+		const i = mac_addresses_list.indexOf(mac_address)
+		if (i<0) return // n'existe pas
+
+		mac_addresses_list.splice(i,1)
+		mac_addresses_names.splice(i,1)
+		oneOf.splice(oneOf.findIndex((p)=>p.properties.mac_address.enum[0]==mac_address),1)
 
-		if (!devices.includes(device)) {
-			devices.push(device)
-			if (!(name===undefined))
-				setDeviceNameInList(device,name)
-		}
 	}
-	async function getDeviceName(device){
-		var dn = "UNKNOWN"
-		try{
-			dn = await device.getName()
+	function addSensorToList(sensor){
+		if (!plugin.schema.properties.peripherals.items.dependencies)
+			plugin.schema.properties.peripherals.items.dependencies={mac_address:{oneOf:[]}}
+		
+		if(plugin.schema.properties.peripherals.items.properties.mac_address.enum==undefined) {
+			plugin.schema.properties.peripherals.items.properties.mac_address.enum=[]
+			plugin.schema.properties.peripherals.items.properties.mac_address.enumNames=[]
 		}
-		catch (error) {}
-		return dn
-	}
+		const mac_addresses_names = plugin.schema.properties.peripherals.items.properties.mac_address.enumNames
+		const mac_addresses_list = plugin.schema.properties.peripherals.items.properties.mac_address.enum
+		const mac_address =  sensor.getMacAddress()
+		const displayName =  sensor.getDisplayName()
 
-	function updateAdapters(){
-		bluetooth.adapters().then((adapters)=>
-			{plugin.schema.properties.adapter.enum = adapters} 
-		)
-	}
-	function updateClassProperties(){ 
-		plugin.schema.properties.peripherals.items.properties.BT_class.enum=[...classMap.keys()]
-		plugin.schema.properties.peripherals.items.dependencies.BT_class.oneOf=[]
-		classMap.forEach(( cls, className )=>{
-			var oneOf = {properties:{BT_class:{enum:[className]}}}
-			cls.metadata.forEach((metadatum,tag)=>{
-				oneOf.properties[tag]={type:'string', title: "Path for "+metadatum.description}
+		var index = mac_addresses_list.indexOf(mac_address)
+		if (index==-1)
+			index = mac_addresses_list.push(mac_address)-1
+		mac_addresses_names[index]= displayName
+		var oneOf = {properties:{mac_address:{enum:[mac_address]}}}
+		
+		oneOf.properties.params={
+			title:`Device parameters`,
+			description: sensor.getDescription(),
+			type:"object",
+			properties:{}
+		}
+		sensor.getParamMetadata().forEach((metadatum,tag)=>{
+			oneOf.properties.params.properties[tag]=metadatum.asJSONSchema()
+		})
+
+		if (sensor.canUseGATT()){
+
+			oneOf.properties.gattParams={
+				title:`GATT Specific device parameters`,
+				description: sensor.getGATTDescription(),
+				type:"object",
+				properties:{}
+			}
+			sensor.getGATTParamMetadata().forEach((metadatum,tag)=>{
+				oneOf.properties.gattParams.properties[tag]=metadatum.asJSONSchema()
 			})
+		}
 
-			plugin.schema.properties.peripherals.items.dependencies.BT_class.oneOf.push(oneOf)
+		oneOf.properties.paths={
+			title:"Signalk Paths",
+			description: `Signalk paths to be updated when ${sensor.getName()}'s values change`,
+			type:"object",
+			properties:{}
+		}
+		sensor.getPathMetadata().forEach((metadatum,tag)=>{
+				oneOf.properties.paths.properties[tag]=metadatum.asJSONSchema()
 		})
+		plugin.schema.properties.peripherals.items.dependencies.mac_address.oneOf.push(oneOf)
+		//plugin.schema.properties.peripherals.items.title=sensor.getName()
+
 	}
-	function startScanner(){
-		bluetooth.getAdapter(app.settings?.btAdapter??adapterID).then(async (adapter) => {
-			app.debug("Starting scan...");
-			try { 
-				await adapter.startDiscovery()
-			}
-			catch (error) {
+	function deviceNameAndAddress(config){
+		return `${config?.name??""}${config.name?" at ":""}${config.mac_address}`
+	}
+	
+	async function createSensor(adapter, config) {
+		return new Promise( ( resolve, reject )=>{
+		var s
+		
+		app.debug(`Waiting on ${deviceNameAndAddress(config)}`)
+		adapter.waitDevice(config.mac_address,config.discoveryTimeout*1000)
+		.then(async (device)=> { 
+			app.debug(`Found ${config.mac_address}`)
+			s = await instantiateSensor(device,config) 
+			sensorMap.set(config.mac_address,s)
+
+			if (s instanceof BLACKLISTED)
+				reject ( `Device is blacklisted (${s.reasonForBlacklisting()}).`)
+			else{
+				addSensorToList(s)
+				s.on("RSSI",(()=>{
+					updateSensorDisplayName(s)
+				}))
+				resolve(s)
 			}
-			plugin.schema.description='Scanning for Bluetooth devices...'	
-			setTimeout( () => {
-				adapter.devices().then((devices)=>{
-					app.debug(`Found: ${util.inspect(devices)}`)
-					devices.forEach( (device) => {
-						adapter.waitDevice(device,discoveryTimeout*1000).then((d)=>{
-							getDeviceName(d).then((dn)=>{
-								addDeviceToList(device, dn )
-							})
-						})
-						.catch ((e)=> {
-							app.debug(e)
-						})
-					})
-					plugin.schema.description=`Scan complete. Found ${devices.length} Bluetooth devices.`
-				})
-				plugin.uiSchema.peripherals['ui:disabled']=false			
-			}, app.settings?.btDiscoveryTimeout ?? discoveryTimeout * 1000)
 		})
+		.catch((e)=>{
+			if (s)
+				s.disconnect()		
+			app.debug(`Unable to communicate with device ${deviceNameAndAddress(config)} Reason: ${e?.message??e}`)
+			reject( e?.message??e )	
+		})})
 	}
+	
+	async function startScanner() {
+		
+		app.debug("Starting scan...");
+		try{ await adapter.stopDiscovery() } catch(error){}
+		try{ await adapter.startDiscovery() } catch(error){}
+	}
+
+	const sensorMap=new Map()
+	var adapter
+	
+	plugin.started=false
+
 	loadClassMap()
-	updateAdapters()
-	updateClassProperties()
-	startScanner()
+	var discoveryIntervalID
+
 	plugin.start = async function (options, restartPlugin) {
-		if (starts>0){
-			app.debug('Plugin restarted');
-			plugin.uiSchema.peripherals['ui:disabled']=true			
-			loadClassMap()
-			updateClassProperties()
-			startScanner()
-		} else {
-			app.debug('Plugin started');
-		}
-		starts++
-		const adapter = await bluetooth.getAdapter(options?.adapter??app.settings?.btAdapter??adapterID)
-		peripherals=options.peripherals
-		if (!(peripherals===undefined)){
-			var found = 0
-			for (const peripheral of peripherals) {
-				
-				addDeviceToList(peripheral.mac_address)				
-				app.setPluginStatus(`Waiting on ${peripheral.mac_address}`);
-				adapter.waitDevice(peripheral.mac_address,1000*peripheral.discoveryTimeout).then(async (device)=>
-				{
 
-					setDeviceNameInList(peripheral.mac_address, await getDeviceName(device))
+		function getDeviceConfig(mac){
+			return deviceConfigs.find((p)=>p.mac_address==mac) 
+		}	
 
-					if (peripheral.active) {
+		function initConfiguredDevice(deviceConfig){
+			app.setPluginStatus(`Initializing ${deviceNameAndAddress(deviceConfig)}`);
+			if (!deviceConfig.discoveryTimeout)
+				deviceConfig.discoveryTimeout = options.discoveryTimeout
+			createSensor(adapter, deviceConfig).then((sensor)=>{
+				deviceConfig.sensor=sensor
+				if (deviceConfig.active) {
+					createPaths(deviceConfig)
+					initPaths(deviceConfig)
+					const result = Promise.resolve(deviceConfig.sensor.connect())
+					result.then(() => {
+						app.debug(`Connected to ${deviceConfig.sensor.getDisplayName()}`);
+						app.setPluginStatus(`Initial scan complete. Connected to ${++found} sensors.`);
+					})
+				}
 
-						var sensorClass = classMap.get(peripheral.BT_class)
-						if (!sensorClass)
-							throw new Error(`File for Class ${peripheral.BT_class} not found.`)
-						createPaths(sensorClass, peripheral)
+			})
+			.catch((error)=>
+				{
+					const msg =`Sensor at ${deviceConfig.mac_address} unavailable. Reason: ${error}`
+					app.debug(msg)
+					app.debug(error)
+					app.setPluginError(msg)
+					deviceConfig.sensor=new MissingSensor(deviceConfig)
+					addSensorToList(deviceConfig.sensor) //add sensor to list with known options
+				})
+		}
+		function findDevices (discoveryTimeout) {
+			app.setPluginStatus("Scanning for new Bluetooth devices...");
+
+			adapter.devices().then( (macs)=>{
+				for (var mac of macs) {	
+					const deviceConfig = getDeviceConfig(mac)
+					const _mac = mac
 
-						peripheral.sensor = new sensorClass(device);
-						await peripheral.sensor.connect();		
-						for (const tag of sensorClass.metadataTags()){
-							const path = peripheral[tag];
-							if (!(path === undefined))
-								peripheral.sensor.on(tag, (val)=>{
-									updatePath(path,val)
-							})
+					if (deviceConfig && deviceConfig.sensor instanceof MissingSensor){
+						removeSensorFromList(deviceConfig.sensor)
+						initConfiguredDevice(deviceConfig)
+					} else
+					{
+						if (!sensorMap.has(_mac)) {
+							if (deviceConfig) continue; 
+							createSensor(adapter,
+								{mac_address:_mac, discoveryTimeout: discoveryTimeout*1000})
+							.then((s)=>
+								app.setPluginStatus(`Found ${s.getDisplayName()}.`))
+							.catch((e)=>
+								app.debug(`Device at ${_mac} unavailable. Reason: ${e}`))
 						}
-						app.debug('Device: '+peripheral.mac_address+' connected.')
-						app.setPluginStatus(`Connected to ${found++} sensors.`);
 					}
-				})
-				.catch ((e)=> {
-					if (peripheral.sensor)
-							peripheral.sensor.disconnect()		
-						app.debug("Unable to connect to device " + peripheral.mac_address +". Reason: "+ e.message )								
-					})
-				.finally( ()=>{
-					app.setPluginStatus(`Connected to ${found} sensors.`);				
 				}
-				)
-			}
+			})
 		}
 
-	} 
-	plugin.stop = async function () {
-		var adapter = await bluetooth.getAdapter(app.settings?.btAdapter??adapterID)
+		function findDeviceLoop(discoveryTimeout, discoveryInterval, immediate=true ){
+			if (immediate)
+				findDevices(discoveryTimeout)
+			discoveryIntervalID = setInterval( findDevices, discoveryInterval*1000, discoveryTimeout)
+		}
+	
+		plugin.started=true
+		plugin.uiSchema.peripherals['ui:disabled']=false
+		sensorMap.clear()
+		deviceConfigs=options?.peripherals??[]
 
-		if (adapter && await adapter.isDiscovering()){
-			try{await adapter.stopDiscovery()} catch (e){
-				app.debug(e.message)
+		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
+		}
+		adapter = await bluetooth.getAdapter(app.settings?.btAdapter??adapterID)
+		await startScanner()
+		if (starts>0){
+			app.debug('Plugin restarting...');
+			if (plugin.schema.properties.peripherals.items.dependencies)
+				plugin.schema.properties.peripherals.items.dependencies.mac_address.oneOf=[]
+		} else {
+			app.debug('Plugin build 2024.10.08 started');
+			
+		}
+		starts++
+		if (!await adapter.isDiscovering())
+			try{
+				await adapter.startDiscovery()
+			} catch (e){
+				app.debug(`Error starting scan: ${e.message}`)
+		}
+		if (!(deviceConfigs===undefined)){
+			var found = 0
+			for (const deviceConfig of deviceConfigs) {
+				initConfiguredDevice(deviceConfig)
 			}
 		}
-		if (!(peripherals === undefined)){
-			for (p of peripherals) {
-				if (p.sensor) 
-					p.sensor.disconnect()
-			} 
+		if (options.discoveryInterval && !discoveryIntervalID) 
+			findDeviceLoop(options.discoveryTimeout, options.discoveryInterval)
+	} 
+	plugin.stop =  async function () {
+		app.debug("Stopping plugin")
+		plugin.stopped=true
+		plugin.uiSchema.peripherals['ui:disabled']=true
+		if ((sensorMap)){
+			sensorMap.forEach(async (sensor, mac)=> {
+				try{
+					await sensor.disconnect()
+					app.debug(`Disconnected from ${mac}`)
+				}
+				catch (e){
+					app.debug(`Error disconnecting from ${mac}: ${e.message}`)
+				}
+			})				
+		}
+		
+		if (discoveryIntervalID) {
+			clearInterval(discoveryIntervalID)
+			discoveryIntervalID=null
 		}
-		//destroy();
-		app.debug('BT Sensors plugin stopped');
+
+		if (adapter && await adapter.isDiscovering())
+			try{
+				await adapter.stopDiscovery()
+				app.debug('Scan stopped')
+			} catch (e){
+				app.debug(`Error stopping scan: ${e.message}`)
+			}
+		app.debug('BT Sensors plugin stopped')
+
 	}
 	
 	return plugin;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "bt-sensors-plugin-sk",
-  "version": "1.0.2",
-  "description": "Bluetooth Sensors for Signalk",
+  "version": "1.1.0-beta.1",
+  "description": "Bluetooth Sensors for Signalk - Beta 20241012",
   "main": "index.js",
   "dependencies": {
     "dbus-next": "^0.10.2",
-    "node-ble": "^1.9.0"
+    "node-ble": "^1.9.0",
+    "int24":"^0.0.1"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"