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

package/index.js

@@ -1,41 +1,57 @@
-const fs = require('fs')
-const util = require('util')
-const path = require('path')
-const semver = require('semver')
 const packageInfo = require("./package.json")
 
 const {createBluetooth} = require('node-ble')
-const { Variant } = require('dbus-next')
+const {Variant} = require('dbus-next')
 const {bluetooth, destroy} = createBluetooth()
 
 const BTSensor = require('./BTSensor.js')
 const BLACKLISTED = require('./sensor_classes/BlackListedDevice.js')
+const { createChannel, createSession } = require("better-sse");
+const { clearTimeout } = require('timers')
+const loadClassMap = require('./classLoader.js')
 
 class MissingSensor  {
 
 
 	constructor(config){
-		this.Metadatum = BTSensor.Metadatum
-		this.addMetadatum=BTSensor.prototype.addMetadatum
-		this.getPathMetadata = BTSensor.prototype.getPathMetadata
-		this.getParamMetadata = BTSensor.prototype.getParamMetadata
+		this.config=config
+		this.addPath=BTSensor.prototype.addPath.bind(this)
+		this.addParameter=BTSensor.prototype.addParameter.bind(this)
+		this.addDefaultPath=BTSensor.prototype.addDefaultPath.bind(this)
+		this.addDefaultParam=BTSensor.prototype.addDefaultParam.bind(this)
+		this.getPath=BTSensor.prototype.getPath.bind(this)
 
-		this.metadata= new Map()
+		this.getJSONSchema = BTSensor.prototype.getJSONSchema.bind(this)
+		this.initSchema = BTSensor.prototype.initSchema.bind(this)
+
+		this.initSchema()
 		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 )
+			this.addPath(key, 
+				{ type: config.paths[key]?.type??'string',  
+				  title: config.paths[key].title} )
 		} )
 		keys = Object.keys(config?.params??{})
 		keys.forEach((key)=>{
-			this.addMetadatum(key, config.params[key]?.type??'string',  config.params[key].description ).isParam=true
+			this.addParameter(key, 
+				{ type: config.params[key]?.type??'string',  
+				  title: config.params[key].title 
+				})
 			this[key]=config.params[key]
 		})
 		this.mac_address = config.mac_address
 		
 	}
 	hasGATT(){
-		return false
+		return this.config.gattParams
+	}
+	initGATTConnection(){
+		
+	}
+
+	getGATTDescription(){
+		return ""
 	}
 	getMetadata(){
 		return this.metadata
@@ -47,409 +63,404 @@ class MissingSensor  {
 		return ""
 	}
 	getName(){
-		return this?.name??"Unknown device"
+		return `${this?.name??"Unknown device"} (OUT OF RANGE)`
 	}	
 	getDisplayName(){
-		return `OUT OF RANGE DEVICE (${this.getName()} ${this.getMacAddress()})`
+		return `(${this.getName()} ${this.getMacAddress()})`
+	}
+	getRSSI(){
+		return NaN
 	}
 	stopListening(){}
 	listen(){}
+	isActive(){
+		return false
+	}
+	elapsedTimeSinceLastContact(){
+		return NaN
+	}
+	getSignalStrength(){
+		return NaN
+	}
+
 }
 module.exports =   function (app) {
-	var adapterID = 'hci0'
-	
-
 	var deviceConfigs
 	var starts=0
-	var classMap
-	
-	var utilities_sk
 	
 	var plugin = {};
 	plugin.id = 'bt-sensors-plugin-sk';
 	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.
-
-	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
-		}
-	}
-
-	function sleep(x) {
-		return new Promise((resolve) => {
-		  setTimeout(() => {
-			resolve(x);
-		  }, x);
-		});
-	  }
-	  async function instantiateSensor(device,config){
-		try{
-		for (var [clsName, cls] of classMap) {
-			if (clsName.startsWith("_")) continue
-			const c = await cls.identify(device)
-			if (c) {
-				c.debug=app.debug
-				const sensor = new c(device,config?.params, config?.gattParams)
-				sensor.debug=app.debug
-				await sensor.init()
-				app.debug(`instantiated ${await BTSensor.getDeviceProp(device,"Address")}`)
-				
-				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
-		var sensor
-		if (config.params?.sensorClass){
-			const c = classMap.get(config.params.sensorClass)
-			c.debug=app.debug
-			sensor = new c(device,config?.params, config?.gattParams)
-			sensor.debug=app.debug
-			await sensor.init()
-		} else{
-			sensor = new (classMap.get('UNKNOWN'))(device)
-			await sensor.init()
-		}
-		return sensor
-	}
-
-	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() {
-		const _classMap = utilities_sk.loadClasses(path.join(__dirname, 'sensor_classes'))
-		classMap = new Map([..._classMap].filter(([k, v]) => !k.startsWith("_") ))
-		const libPath = app.config.appPath +(
-			semver.gt(app.config.version,"2.13.5")?"dist":"lib" 
-		)
-		//+ app.config.version 
-		import(libPath+"/modules.js").then( (modulesjs)=>{
-		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}`)
 	
 	plugin.schema = {			
 		type: "object",
-		description: "NOTE: \n 1) Plugin must be enabled to configure your sensors. \n"+
-		"2) You will have to wait until the scanner has found 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:["adapter","discoveryTimeout", "discoveryInterval"],
 		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"]},
-
+				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,
-				minimum: 0,
-				multipleOf: 10
+				minimum: 0
 			 },
-			peripherals:
-				{ type: "array", title: "Sensors", items:{
-					title: "", type: "object",
-					required:["mac_address", "discoveryTimeout"],
-					properties:{
-					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 
-					}
-					}
-					
-				}
-			}
 		}
 	}
-	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
-
-		var index = mac_addresses_list.indexOf(mac_address)
-		if (index!=-1)
-			mac_addresses_names[index]= displayName
-	}
 
-	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()
+	
+	plugin.started=false
+	
+	var discoveryIntervalID, progressID, progressTimeoutID, deviceHealthID
+	var adapter 
+	const channel = createChannel()
+	const classMap = loadClassMap(app)
+	const sensorMap=new Map()
+
+	
+/*	plugin.registerWithRouter = function(router) {
+		router.get('/sendPluginState', async (req, res) => {
 		
-		const i = mac_addresses_list.indexOf(mac_address)
-		if (i<0) return // n'existe pas
+			res.status(200).json({
+				"state":(plugin.started?"started":"stopped")
+			})
+		});
+		router.get("/sse", async (req, res) => {
+			const session = await createSession(req, res);
+			channel.register(session)
+	   });
+	
+	}*/
+
+	plugin.start = async function (options, restartPlugin) {
+		plugin.started=true
+		var adapterID=options.adapter
+		var foundConfiguredDevices=0
 
-		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)
+		plugin.registerWithRouter = function(router) {
 
-	}
-	function addSensorToList(sensor){
-		if (!plugin.schema.properties.peripherals.items.dependencies)
-			plugin.schema.properties.peripherals.items.dependencies={mac_address:{oneOf:[]}}
+			router.post('/updateSensorData', async (req, res) => {
+				app.debug(req.body)
+				const i = deviceConfigs.findIndex((p)=>p.mac_address==req.body.mac_address) 
+				if (i<0){
+					if (!options.peripherals){
+						if (!options.hasOwnProperty("peripherals"))
+							options.peripherals=[]
+			
+						options.peripherals=[]
+					}
+					options.peripherals.push(req.body)
+				} else {
+					options.peripherals[i] = req.body
+				}
+				app.savePluginOptions(
+					options, async () => {
+						app.debug('Plugin options saved')
+						res.status(200).json({message: "Sensor updated"})
+						const sensor = sensorMap.get(req.body.mac_address)
+						if (sensor) {
+							removeSensorFromList(sensor)
+							if (sensor.isActive()) 
+								await sensor.stopListening()
+							initConfiguredDevice(req.body)
+						} 
+						
+					}
+				)
+				
+			});
+			router.post('/removeSensorData', async (req, res) => {
+				app.debug(req.body)
+				const i = deviceConfigs.findIndex((p)=>p.mac_address==req.body.mac_address) 
+				if (i>=0){
+					deviceConfigs.splice(i,1)
+				}
+				if (sensorMap.has(req.body.mac_address))
+					sensorMap.delete(req.body.mac_address)
+				app.savePluginOptions(
+					options, () => {
+						app.debug('Plugin options saved')
+						res.status(200).json({message: "Sensor updated"})
+						channel.broadcast({},"resetSensors")
+					}
+				)
+				
+			});
+
+			router.post('/updateBaseData', async (req, res) => {
+				
+				app.debug(req.body)
+				Object.assign(options,req.body)
+				app.savePluginOptions(
+					options, () => {
+						app.debug('Plugin options saved')
+						res.status(200).json({message: "Plugin updated"})
+						channel.broadcast({},"pluginRestarted")
+						restartPlugin(options)
+					}
+				)
+			});
 		
-		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=[]
-		}
-		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()
-
-		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()
-		})
+			router.get('/getBaseData', (req, res) => {
+				
+				res.status(200).json(
+					{
+					schema: plugin.schema,
+					data: {
+						adapter: options.adapter,
+						transport: options.transport,
+						discoveryTimeout: options.discoveryTimeout,
+						discoveryInterval: options.discoveryInterval
+					}
+					}
+				);
+			})
+			router.get('/getSensors', (req, res) => {
+				app.debug("Sending sensors")
+				const t = sensorsToJSON()
+				res.status(200).json(t)
+			  });
+
+			router.get('/getProgress', (req, res) => {
+				app.debug("Sending progress")
+				const json = {"progress":foundConfiguredDevices/deviceConfigs.length, "maxTimeout": 1, 
+							  "deviceCount":foundConfiguredDevices, 
+							  "totalDevices": deviceConfigs.length}
+				res.status(200).json(json)
+				
+			  });
+			
+			router.get('/getPluginState', async (req, res) => {
+		
+				res.status(200).json({
+					"state":(plugin.started?"started":"stopped")
+				})
+			});
+			router.get("/sse", async (req, res) => {
+				const session = await createSession(req, res);
+				channel.register(session)
+		   });
+	
 
-		if (sensor.hasGATT()){
+		};
 
-			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()
-			})
+		function sensorsToJSON(){
+			return Array.from(
+				Array.from(sensorMap.values()).filter((s)=>!(s instanceof BLACKLISTED) ).map(
+				sensorToJSON
+			))
 		}
 
-		oneOf.properties.paths={
-			title:"Signalk Paths",
-			description: `Signalk paths to be updated when ${sensor.getName()}'s values change`,
-			type:"object",
-			properties:{}
+		function getSensorInfo(sensor){
+	
+			const etslc = sensor.elapsedTimeSinceLastContact()
+			return { mac: sensor.getMacAddress(),
+				     name: sensor.getName(),
+					 RSSI: sensor.getRSSI(),
+					 signalStrength: sensor.getSignalStrength(),
+					 lastContactDelta: etslc
+			}
 		}
-		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 deviceNameAndAddress(config){
-		return `${config?.name??""}${config.name?" at ":""}${config.mac_address}`
-	}
-	
-	async function createSensor(adapter, config) {
-		return new Promise( ( resolve, reject )=>{
-		var s
+		function sensorToJSON(sensor){
+			const config = getDeviceConfig(sensor.getMacAddress())
+			return {
+					info: getSensorInfo(sensor),
+					schema: sensor.getJSONSchema(),
+					config: config?config:{}
+			
+				}
+		}
+		async function startScanner(transport) {
 		
-		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)
+			app.debug("Starting scan...");
+			//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)
 			}
-		})
-		.catch((e)=>{
-			if (s)
-				s.stopListening()
-
-			app.debug(`Unable to communicate with device ${deviceNameAndAddress(config)} Reason: ${e?.message??e}`)
-			app.debug(e)
-			reject( e?.message??e )	
-		})})
-	}
-	
-	async function startScanner(transport) {
-		
-		app.debug("Starting scan...");
-		//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()
-	
-	plugin.started=false
+		function updateSensor(sensor){
+			channel.broadcast(getSensorInfo(sensor), "sensorchanged")			
+		}
 
-	loadClassMap()
-	var discoveryIntervalID
-	var adapter 
-	var adapterPower
-	plugin.start = async function (options, restartPlugin) {
-		plugin.started=true
+		function removeSensorFromList(sensor){
+			sensorMap.delete(sensor.getMacAddress())
+			channel.broadcast({mac:sensor.getMacAddress()},"removesensor")
+		}
 		
-		var adapterID=options.adapter
+		function addSensorToList(sensor){
+			app.debug(`adding sensor to list ${sensor.getMacAddress()}`)
+			if (sensorMap.has(sensor.getMacAddress()) )
+				debugger 
+			sensorMap.set(sensor.getMacAddress(),sensor)
+			channel.broadcast(sensorToJSON(sensor),"newsensor");
+		}
+		function deviceNameAndAddress(config){
+			return `${config?.name??""}${config.name?" at ":""}${config.mac_address}`
+		}
 		
+		function createSensor(adapter, config) {
+			return new Promise( ( resolve, reject )=>{
+			var s
+			const startNumber=starts
+			//app.debug(`Waiting on ${deviceNameAndAddress(config)}`)
+			adapter.waitDevice(config.mac_address,(config?.discoveryTimeout??30)*1000)
+			.then(async (device)=> { 
+				if (startNumber != starts ) {
+					return
+				}
+				//app.debug(`Found ${config.mac_address}`)
+				s = await instantiateSensor(device,config) 
+	
+				if (s instanceof BLACKLISTED)
+					reject ( `Device is blacklisted (${s.reasonForBlacklisting()}).`)
+				else{
+					addSensorToList(s)
+					s._lastRSSI=-1*Infinity
+					s.on("RSSI",(()=>{
+						if (Date.now()-s._lastRSSI > 20000) { //only update RSSI on client every five seconds
+							//app.debug(`${s.getMacAddress()} ${Date.now()-s._lastRSSI}`) 
+							s._lastRSSI=Date.now()
+							updateSensor(s)
+						}	
+
+					}))
+					resolve(s)
+				}
+			})
+			.catch((e)=>{
+				if (s)
+					s.stopListening()
+				if (startNumber == starts ) {
+					app.debug(`Unable to communicate with device ${deviceNameAndAddress(config)} Reason: ${e?.message??e}`)
+					app.debug(e)
+					reject( e?.message??e )
+				}	
+			})})
+		}
 		function getDeviceConfig(mac){
 			return deviceConfigs.find((p)=>p.mac_address==mac) 
 		}	
+		async function instantiateSensor(device,config){
+			try{
+			for (var [clsName, cls] of classMap) {
+				if (clsName.startsWith("_")) continue
+				const c = await cls.identify(device)
+				if (c) {
+					c.debug=app.debug
+					const sensor = new c(device,config?.params, config?.gattParams)
+					sensor.debug=app.debug
+					sensor.app=app
+					sensor._adapter=adapter //HACK!
+
+					await sensor.init()
+					//app.debug(`instantiated ${await BTSensor.getDeviceProp(device,"Address")}`)
+					
+					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
+			var sensor 
+			if (config.params?.sensorClass){
+				var c = classMap.get(config.params.sensorClass)
+			} else{
+				c = classMap.get('UNKNOWN')
+			}
+			c.debug=app.debug
+			sensor = new c(device,config?.params, config?.gattParams)
+			sensor.debug=app.debug
+			sensor.app=app
 
+			await sensor.init()
+			return sensor
+		}	
+		
 		function initConfiguredDevice(deviceConfig){
+			const startNumber=starts
 			app.setPluginStatus(`Initializing ${deviceNameAndAddress(deviceConfig)}`);
 			if (!deviceConfig.discoveryTimeout)
 				deviceConfig.discoveryTimeout = options.discoveryTimeout
 			createSensor(adapter, deviceConfig).then((sensor)=>{
-				deviceConfig.sensor=sensor
+				if (startNumber != starts ) {
+						return
+				}	
 				if (deviceConfig.active) {
-					if (deviceConfig.paths){
-						createPaths(deviceConfig)
-						initPaths(deviceConfig)
-					}
-					const result = Promise.resolve(deviceConfig.sensor.listen())
-					result.then(() => {
-						app.debug(`Listening for changes from ${deviceConfig.sensor.getDisplayName()}`);
-						app.setPluginStatus(`Initial scan complete. Listening to ${++found} sensors.`);
-					})
-
+					app.setPluginStatus(`Listening to ${++foundConfiguredDevices} sensors.`);
+					sensor.activate(deviceConfig, plugin)
 				}
-
+				
 			})
 			.catch((error)=>
 				{
+					if (deviceConfig.unconfigured) return
+					if (startNumber != starts ) {
+						return
+					}	
 					const msg =`Sensor at ${deviceConfig.mac_address} unavailable. Reason: ${error}`
 					app.debug(msg)
 					app.debug(error)
 					if (deviceConfig.active) 
 						app.setPluginError(msg)
-					deviceConfig.sensor=new MissingSensor(deviceConfig)
-					addSensorToList(deviceConfig.sensor) //add sensor to list with known options
+					const sensor=new MissingSensor(deviceConfig)
+					++foundConfiguredDevices
+					
+					addSensorToList(sensor) //add sensor to list with known options
 				
 				})
 		}
 		function findDevices (discoveryTimeout) {
+			const startNumber = starts
 			app.setPluginStatus("Scanning for new Bluetooth devices...");
 
 			adapter.devices().then( (macs)=>{
-				for (var mac of macs) {	
-					const deviceConfig = getDeviceConfig(mac)
-					const _mac = mac
-
-					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}`))
+				if (startNumber != starts ) {
+					return
+				}
+				for (const mac of macs) {	
+					var deviceConfig = getDeviceConfig(mac)
+					const sensor = sensorMap.get(mac)
+
+					if (sensor) {
+						if (sensor instanceof MissingSensor){
+							removeSensorFromList(sensor)
+							initConfiguredDevice(deviceConfig)
 						}
+					} else {
+
+						if (!deviceConfig) {
+							deviceConfig = {mac_address: mac, 
+											discoveryTimeout: discoveryTimeout*1000, 
+											active: false, unconfigured: true}
+							initConfiguredDevice(deviceConfig) 
+						} 
 					}
 				}
 			})
@@ -458,10 +469,13 @@ module.exports =   function (app) {
 		function findDeviceLoop(discoveryTimeout, discoveryInterval, immediate=true ){
 			if (immediate)
 				findDevices(discoveryTimeout)
-			discoveryIntervalID = setInterval( findDevices, discoveryInterval*1000, discoveryTimeout)
+			discoveryIntervalID = 
+				setInterval( findDevices, discoveryInterval*1000, discoveryTimeout)
 		}
-	
-	
+
+		channel.broadcast({state:"started"},"pluginstate")
+
+
 		if (!adapterID || adapterID=="")
 			adapterID = "hci0"
 		//Check if Adapter has changed since last start()
@@ -483,39 +497,32 @@ module.exports =   function (app) {
 
 			await adapter.helper._prepare()
 			adapter.helper._propsProxy.on('PropertiesChanged', async (iface,changedProps,invalidated) => {
+				app.debug(changedProps)
 				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)
-						}
+						await restartPlugin(options)
 					}
 				}
 			})
 			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()
+		if (channel)
+			channel.broadcast({state:"started"},"pluginstate")
 		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
 		}
 
@@ -526,15 +533,10 @@ module.exports =   function (app) {
 			plugin.schema.properties.adapter.enum.push(a.adapter)
 			plugin.schema.properties.adapter.enumNames.push(`${a.adapter} @ ${ await a.getAddress()} (${await a.getName()})`)
 		}
-
-		plugin.uiSchema.adapter={'ui:disabled': (activeAdapters.length==1)}
-
 		
 		await startScanner(options.transport)
 		if (starts>0){
 			app.debug(`Plugin ${packageInfo.version} restarting...`);
-			if (plugin.schema.properties.peripherals.items.dependencies)
-				plugin.schema.properties.peripherals.items.dependencies.mac_address.oneOf=[]
 		} else {
 			app.debug(`Plugin ${packageInfo.version} started` )
 			
@@ -542,43 +544,90 @@ module.exports =   function (app) {
 		starts++
 		if (!await adapter.isDiscovering())
 			try{
-				await adapter.startDiscovery()
+				await startScanner()
 			} catch (e){
 				app.debug(`Error starting scan: ${e.message}`)
 		}
 		if (!(deviceConfigs===undefined)){
-			var found = 0
-			for (const deviceConfig of deviceConfigs) {
-				initConfiguredDevice(deviceConfig)
+			const maxTimeout=Math.max(...deviceConfigs.map((dc)=>dc?.discoveryTimeout??options.discoveryTimeout))
+			var progress = 0
+			if (progressID==null) 
+			progressID  = setInterval(()=>{
+				channel.broadcast({"progress":++progress, "maxTimeout": maxTimeout, "deviceCount":foundConfiguredDevices, "totalDevices": deviceConfigs.length},"progress")
+				if ( foundConfiguredDevices==deviceConfigs.length){
+					app.debug("progress complete") 
+					progressID,progressTimeoutID = null
+					clearTimeout(progressTimeoutID)
+					clearInterval(progressID)
+					progressID = null
+				}
+			},1000); 
+			if (progressTimeoutID==null)
+			progressTimeoutID = setTimeout(()=> {
+				app.debug("progress timed out ")
+				if (progressID) {
+
+					clearInterval(progressID);
+					progressID=null
+					channel.broadcast({"progress":maxTimeout, "maxTimeout": maxTimeout, "deviceCount":foundConfiguredDevices, "totalDevices": deviceConfigs.length},"progress")
+				} 
+			}, (maxTimeout+1)*1000);
+
+			for (const config of deviceConfigs) {
+				initConfiguredDevice(config)
 			}
 		}
+		const minTimeout=Math.min(...deviceConfigs.map((dc)=>dc?.discoveryTimeout??options.discoveryTimeout))
+		const intervalTimeout = ((minTimeout==Infinity)?(options?.discoveryTimeout??plugin.schema.properties.discoveryTimeout.default):minTimeout)*1000
+		deviceHealthID = setInterval( ()=> {
+			sensorMap.forEach((sensor)=>{
+				const config = getDeviceConfig(sensor.getMacAddress())
+				const dt = config?.discoveryTimeout??options.discoveryTimeout
+				const lc=sensor.elapsedTimeSinceLastContact()
+				if (lc > dt) { 
+					app.debug(`${sensor.getMacAddress()} not heard from in ${lc} seconds`)
+					channel.broadcast(getSensorInfo(sensor), "sensorchanged")
+				}
+			})
+		}, intervalTimeout)
+		
+		if (!options.hasOwnProperty("discoveryInterval" )) //no config -- first run
+			options.discoveryInterval = plugin.schema.properties.discoveryInterval.default
+
 		if (options.discoveryInterval && !discoveryIntervalID) 
-			findDeviceLoop(options.discoveryTimeout, options.discoveryInterval)
+			findDeviceLoop(options?.discoveryTimeout??plugin.schema.properties.discoveryTimeout.default, 
+						   options.discoveryInterval)
 	} 
 	plugin.stop =  async function () {
 		app.debug("Stopping plugin")
 		plugin.stopped=true
 		plugin.started=false
-		plugin.uiSchema.peripherals['ui:disabled']=true
+		channel.broadcast({state:"stopped"},"pluginstate")
+		if (discoveryIntervalID) {
+			clearInterval(discoveryIntervalID)
+			discoveryIntervalID=null
+		}
+		if (progressID) {
+			clearInterval(progressID)
+			progressID=null
+		}
+		if (progressTimeoutID) {
+			clearTimeout(progressTimeoutID)
+			progressTimeoutID=null
+		}
+
 		if ((sensorMap)){
-			plugin.schema.properties.peripherals.items.properties.mac_address.enum=[]
-			plugin.schema.properties.peripherals.items.properties.mac_address.enumNames=[]
-			sensorMap.forEach(async (sensor, mac)=> {
+				for await (const sensorEntry of sensorMap.entries()) {
 				try{
-					await sensor.stopListening()
-					app.debug(`No longer listening to ${mac}`)
+					await sensorEntry[1].stopListening()
+					app.debug(`No longer listening to ${sensorEntry[0]}`)
 				}
 				catch (e){
-					app.debug(`Error stopping listening to ${mac}: ${e.message}`)
+					app.debug(`Error stopping listening to ${sensorEntry[0]}: ${e.message}`)
 				}
-			})				
-		}
-		
-		if (discoveryIntervalID) {
-			clearInterval(discoveryIntervalID)
-			discoveryIntervalID=null
+			}
 		}
-
+		sensorMap.clear()
 		if (adapter && await adapter.isDiscovering())
 			try{
 				await adapter.stopDiscovery()
@@ -586,9 +635,10 @@ module.exports =   function (app) {
 			} catch (e){
 				app.debug(`Error stopping scan: ${e.message}`)
 			}
+
 		app.debug('BT Sensors plugin stopped')
 
 	}
-	
+
 	return plugin;
 }