bt-sensors-plugin-sk 1.2.5 → 1.2.6-beta

package/BTSensor.js

@@ -2,16 +2,19 @@ const { Variant } = require('dbus-next');
 const { log } = require('node:console');
 const EventEmitter = require('node:events');
 const AutoQueue =  require("./Queue.js")
+const DistanceManager = require("./DistanceManager")
 
 /** 
  * @author Andrew Gerngross <oh.that.andy@gmail.com>
 */
 
+
 /**
  * {@link module:node-ble}
  */
 
 const BTCompanies = require('./bt_co.json');
+
 const connectQueue = new AutoQueue()
 
 /**
@@ -54,38 +57,8 @@ 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.replace(/\s+/g,'_') : `${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 
@@ -102,13 +75,17 @@ function preparePath(obj, str) {
 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 IsRoaming = false;
 
     static SensorDomains={
         unknown: { name: "unknown", description: "Unknown sensor domain "},
         environmental: { name: "environmental", description: "Sensors that measure environmental conditions - air temperature, humidity etc."},
         electrical: { name: "electrical", description: "Electrical sensor - chargers, batteries, inverters etc."},
         propulsion: { name: "propulsion", description: "Sensors that measure engine state"},
-        tanks: { name: "tanks", description: "Sensors that measure level in tanks (gas, propane, water etc.) "}
+        tanks: { name: "tanks", description: "Sensors that measure level in tanks (gas, propane, water etc.) "},
+        beacons: { name: "beacons", description: "iBeacon/Eddystone sensor tags"}
     }
     static Domain = this.SensorDomains.unknown   
     /**
@@ -254,6 +231,8 @@ class BTSensor extends EventEmitter {
         throw new Error("BTSensor is an abstract class. ::identify must be implemented by the subclass")
     }
 
+    static DisplayName() { return `${this.name} (${this.Domain.name}) `}
+
     /**
      * getManufacturerID is used to help ID the manufacturer of a device
      * 
@@ -634,27 +613,49 @@ class BTSensor extends EventEmitter {
         return this.currentProperties.Address
     }
 
-    getImage(){
-        return "bluetooth-logo.png" 
+    static ImageFile = "bluetooth-logo.png" 
+    static Description = "Bluetooth device"
+    static Manufacturer = "Unknown"
+    static ImageSrc =  "../bt-sensors-plugin-sk/images/"
+
+    getImageFile(){
+        return this.constructor.ImageFile
+    }
+    getImageSrc(){
+        return this.constructor.ImageSrc
+    }
+    static getImageHTML() {
+        return `<img src="${this.ImageSrc}${this.ImageFile}" style="float: left; margin-right: 10px;"  height="150" object-fit="cover" ></img>`
     }
+
     getImageHTML(){
-        return `<img src="../bt-sensors-plugin-sk/images/${this.getImage()}" height="150" object-fit="cover" ></img>`
+        return `<img src="${this.getImageSrc()}${this.getImageFile()}" style="float: left; margin-right: 10px;" height="150" object-fit="cover" ></img>`
     }
 
     getTextDescription(){
         return `${this.getName()} from ${this.getManufacturer()}`
     }
 
+    static getTextDescription(){
+        return `${this.name} from ${this.Manufacturer}`
+    }
+
     getDescription(){
         return `<div>${this.getImageHTML()} ${this.getTextDescription()} </div>`
+    }
 
+    static getDescription(){
+        return `<div>${this.getImageHTML()} ${this.getTextDescription()} </div>`
     }
+
     getName(){
         const name = this?.name??this.currentProperties.Name
         return name?name:"Unknown"
 
     }
     macAndName(){
+        if (this.getMacAddress()==null) 
+            debugger
         return `${this.getName().replaceAll(':', '-').replaceAll(" ","_")}-${this.getMacAddress().replaceAll(':', '-')}`
     }
     getNameAndAddress(){
@@ -892,19 +893,19 @@ class BTSensor extends EventEmitter {
                 this.app.handleMessage(id, 
                 {
                 updates: 
-                    [{ meta: [{path:  preparePath(this, path), value: { units: pathMeta?.unit }}]}]
+                    [{ meta: [{path:  this.preparePath(path), value: { units: pathMeta?.unit }}]}]
                 })
             }
         })
 	}
 
 	 initPaths(deviceConfig, id){
-        const source = `${this.getName()} (bt-sensors-plugin-sk)`
+        const source = this.getName()
 		Object.keys(this.getPaths()).forEach((tag)=>{
             const pathMeta=this.getPath(tag)
 			const path = deviceConfig.paths[tag];
 			if (!(path === undefined)) {
-                let preparedPath =  preparePath(this, path)
+                let preparedPath =  this.preparePath(path)
                 this.on(tag, (val)=>{
 					if (pathMeta.notify){
 						this.app.notify(tag, val, id )
@@ -922,6 +923,44 @@ class BTSensor extends EventEmitter {
         return (Date.now()-this?._lastContact??Date.now())/1000
     }
 
+    prepareConfig(config){
+        if (!config.params.sensorClass)
+            config.params.sensorClass=this.constructor.name
+    }
+
+    preparePath(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 = this[keyToAccess];
+            if (typeof evalResult === 'function'){
+                evalResult= evalResult.call(this)
+            }
+
+            resultString += evalResult !== undefined ? evalResult.replace(/\s+/g,'_') : `${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
+  }
+
 
 }
 

package/DistanceManager.js

@@ -0,0 +1,249 @@
+const { LRUCache } = require('lru-cache')
+
+
+class DistanceManager {
+    static METHOD_AVG = 1;
+    static METHOD_WEIGHTED_AVG = 2;
+    static METHOD_LAST_FEW_SAMPLES = 3;
+
+    Constant = {
+        DISTANCE_FIND_LAST_FEW_SAMPLE_TIME_FRAME_MILLIS: 5000, // Example value, adjust as needed
+        DISTANCE_FIND_TIME_FRAME_MILLIS: 10000, // Example value, adjust as needed
+        LAST_FEW_SAMPLE_COUNT: 5 // Example value, adjust as needed
+    };
+
+
+    #beaconRssiSampleMap = new LRUCache({ttl:1000*60*5, ttlAutopurge: true}); // Using LRUCache with a ttl of 5m for beaconRssiSampleMap
+
+    #timeFormatter = new Intl.DateTimeFormat('en-US', {
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false // Use 24-hour format
+    });
+
+    constructor(constants) {
+        Object.assign(this.Constant,constants)
+        // Constructor is empty as initialization is done with property declarations
+    }
+
+    addSample(macAddress, rssi) {
+        // In Node.js (JavaScript), maps and objects are not inherently synchronized like
+        // Java's synchronized blocks. If this were a multi-threaded Node.js environment
+        // (e.g., Worker Threads), you'd need explicit locking mechanisms or message passing.
+        // For typical single-threaded Node.js, direct access is usually fine,
+        // but if concurrency is a concern, consider a mutex implementation.
+        let samples = this.#beaconRssiSampleMap.get(macAddress);
+        if (!samples) {
+            samples = new Map(); // Using Map instead of LinkedHashMap
+            this.#beaconRssiSampleMap.set(macAddress, samples);
+        }
+        samples.set(Date.now(), rssi);
+    }
+
+    getDistance(macAddress, txPower, method, debugLog) {
+        const samples = this.#beaconRssiSampleMap.get(macAddress);
+        if (!samples) {
+            return 0;
+        }
+
+        // Create a new Map to avoid modifying the original during filtering/processing
+        const currentSamples = new Map(samples);
+
+        const fromTimestamp = Date.now() - (method === DistanceManager.METHOD_LAST_FEW_SAMPLES ?
+            this.Constant.DISTANCE_FIND_LAST_FEW_SAMPLE_TIME_FRAME_MILLIS : this.Constant.DISTANCE_FIND_TIME_FRAME_MILLIS);
+        const toTimestamp = Date.now();
+
+        const filteredRssi = this.#filterRssiSamplesWithinTimeFrame(currentSamples, fromTimestamp, toTimestamp);
+
+        const smoothRssi = this.#reduceNoiseFromRSSI(filteredRssi);
+
+        let rssi = 0;
+        let distance;
+
+        switch (method) {
+            case DistanceManager.METHOD_AVG:
+                rssi = this.#calculateAverage(smoothRssi);
+                break;
+            case DistanceManager.METHOD_WEIGHTED_AVG:
+                rssi = this.#calculateWeightedAverageOfRssiSamples(smoothRssi);
+                break;
+            case DistanceManager.METHOD_LAST_FEW_SAMPLES:
+                if (samples.size >= this.Constant.LAST_FEW_SAMPLE_COUNT) {
+                    rssi = this.#calculateAverage(smoothRssi);
+                } else {
+                    return -1;
+                }
+                break;
+            default:
+                // Handle unknown method or provide a default
+                console.warn(`Unknown method: ${method}`);
+                return 0;
+        }
+
+        distance = this.#calculateAccuracy(txPower, rssi);
+
+        if (debugLog) {
+            this.#logSamples(smoothRssi, fromTimestamp, toTimestamp, rssi, distance);
+        }
+        return distance;
+    }
+
+    #removeOutliers(filteredRssi, avgOutlierRssi, outlierConstant) {
+        const outlierRemoveRssi = new Map();
+
+        const minRssi = Math.floor(avgOutlierRssi) - outlierConstant;
+        const maxRssi = Math.floor(avgOutlierRssi) + outlierConstant;
+
+        for (const [timestamp, value] of filteredRssi.entries()) {
+            if (value >= minRssi && value <= maxRssi) {
+                outlierRemoveRssi.set(timestamp, value);
+            }
+        }
+        return outlierRemoveRssi;
+    }
+
+    #reduceNoiseFromRSSI(filteredRssi) {
+        const smoothRssi = new Map();
+
+        const rssiEntries = Array.from(filteredRssi.entries());
+        const totalRssi = rssiEntries.length;
+
+        for (let i = 0; i < totalRssi; i++) {
+            const [currentTimestamp, currentRssi] = rssiEntries[i];
+            const nextRssi = rssiEntries[i + 1] ? rssiEntries[i + 1][1] : currentRssi; // If no next, use current
+
+            const avgRssi = Math.floor((currentRssi + nextRssi) / 2);
+            smoothRssi.set(currentTimestamp, avgRssi);
+        }
+        return smoothRssi;
+    }
+
+    #filterRssiSamplesWithinTimeFrame(rssiSamples, fromTimestamp, toTimestamp) {
+        const filteredSamples = new Map();
+        for (const [timestamp, rssi] of rssiSamples.entries()) {
+            if (fromTimestamp === 0) {
+                if (timestamp <= toTimestamp) {
+                    filteredSamples.set(timestamp, rssi);
+                }
+            } else if (timestamp > fromTimestamp && timestamp <= toTimestamp) {
+                filteredSamples.set(timestamp, rssi);
+            }
+        }
+        return filteredSamples;
+    }
+
+    #calculateAverage(filteredRssi) {
+        let sum = 0;
+        if (filteredRssi.size === 0) {
+            return 0; // Avoid division by zero
+        }
+        for (const rssi of filteredRssi.values()) {
+            sum += rssi;
+        }
+        return sum / filteredRssi.size;
+    }
+
+    #calculateWeightedAverageOfRssiSamples(filteredRssi) {
+        // 1. Find count
+        const uniqueRssiCountMap = new Map();
+        for (const rssi of filteredRssi.values()) {
+            uniqueRssiCountMap.set(rssi, (uniqueRssiCountMap.get(rssi) || 0) + 1);
+        }
+
+        // 2. Find weight of each rssi
+        const uniqueRssiWeightMap = new Map();
+        const totalSamples = filteredRssi.size;
+        if (totalSamples === 0) {
+            return 0; // Avoid division by zero
+        }
+        for (const [rssi, count] of uniqueRssiCountMap.entries()) {
+            const weight = count / totalSamples;
+            uniqueRssiWeightMap.set(rssi, weight);
+        }
+
+        // 3. Calculate weighted average
+        let sum = 0;
+        for (const [rssi, weight] of uniqueRssiWeightMap.entries()) {
+            sum += rssi * weight;
+        }
+        return sum;
+    }
+
+    #calculateAccuracy(txPower, rssi) {
+        if (rssi === 0) {
+            return -1.0;
+        }
+
+        const ratio = rssi * 1.0 / txPower;
+        if (ratio < 1.0) {
+            return Math.pow(ratio, 10);
+        } else {
+            return ((0.42093) * Math.pow(ratio, 6.9476)) + 0.54992; // Nexus 5 formula
+        }
+    }
+
+    #logSamples(samples, fromTimestamp, toTimestamp, rssiWeightedAvg, distance) {
+        const object = {};
+        const array = [];
+        try {
+            for (const [timestamp, rssi] of samples.entries()) {
+                const jsonSample = {
+                    rssi: rssi,
+                    timestamp: this.#getTimeString(timestamp)
+                };
+                array.push(jsonSample);
+            }
+            object.calc_rssi = rssiWeightedAvg;
+            object.distance = distance;
+            object.start_time = this.#getTimeString(fromTimestamp);
+            object.end_time = this.#getTimeString(toTimestamp);
+            object.samples = array;
+            // In Node.js, 'console.log' is used instead of 'Log.d'
+            //console.log("SampleData", JSON.stringify(object, null, 2)); // Prettify output
+        } catch (error) {
+            console.error("Error logging samples:", error); // Use console.error for errors
+        }
+    }
+
+    #getTimeString(millis) {
+        const d = new Date(millis);
+        return this.#timeFormatter.format(d);
+    }
+}
+
+// Example Usage (for demonstration purposes)
+/*
+// You might need to define or import Constant with your specific values
+const Constant = {
+    DISTANCE_FIND_LAST_FEW_SAMPLE_TIME_FRAME_MILLIS: 5000,
+    DISTANCE_FIND_TIME_FRAME_MILLIS: 10000,
+    LAST_FEW_SAMPLE_COUNT: 5
+};
+
+const distanceManager = new DistanceManager();
+
+// Simulate adding some samples
+distanceManager.addSample("AA:BB:CC:DD:EE:FF", -70);
+setTimeout(() => distanceManager.addSample("AA:BB:CC:DD:EE:FF", -72), 500);
+setTimeout(() => distanceManager.addSample("AA:BB:CC:DD:EE:FF", -68), 1000);
+setTimeout(() => distanceManager.addSample("AA:BB:CC:DD:EE:FF", -75), 1500);
+setTimeout(() => distanceManager.addSample("AA:BB:CC:DD:EE:FF", -71), 2000);
+setTimeout(() => distanceManager.addSample("AA:BB:CC:DD:EE:FF", -69), 2500);
+setTimeout(() => distanceManager.addSample("AA:BB:CC:DD:EE:FF", -73), 3000);
+
+// Get distance after some time
+setTimeout(() => {
+    const txPower = -59; // Example TxPower
+    let distance = distanceManager.getDistance("AA:BB:CC:DD:EE:FF", txPower, DistanceManager.METHOD_AVG, true);
+    console.log(`Calculated Distance (AVG): ${distance.toFixed(2)} meters`);
+
+    distance = distanceManager.getDistance("AA:BB:CC:DD:EE:FF", txPower, DistanceManager.METHOD_WEIGHTED_AVG, true);
+    console.log(`Calculated Distance (WEIGHTED_AVG): ${distance.toFixed(2)} meters`);
+
+    distance = distanceManager.getDistance("AA:BB:CC:DD:EE:FF", txPower, DistanceManager.METHOD_LAST_FEW_SAMPLES, true);
+    console.log(`Calculated Distance (LAST_FEW_SAMPLES): ${distance.toFixed(2)} meters`);
+
+}, 4000);
+*/
+module.exports=DistanceManager

package/Mixin.js

@@ -0,0 +1,19 @@
+function bindThisToThat(obj1, obj2){
+        for (let method of getInstanceMethodNames(obj1)) {
+            obj1[method]=obj1[method].bind(obj2)
+        }
+}
+
+function getInstanceMethodNames (obj) {
+    return Object
+        .getOwnPropertyNames (Object.getPrototypeOf (obj))
+        .filter(name => (name !== 'constructor' && typeof obj[name] === 'function'));
+}
+
+class Mixin{
+    constructor(obj){
+        bindThisToThat(this, obj)
+    }
+}
+
+module.exports=Mixin

package/OutOfRangeDevice.js

@@ -0,0 +1,46 @@
+
+const { toPathSchema } = require('@rjsf/utils');
+const EventEmitter = require('node:events');
+
+class OutOfRangeDevice extends EventEmitter{
+    constructor(adapter, config){
+        super()
+        this.helper=new EventEmitter()
+        this.helper._prepare=()=>{}
+        this.helper.callMethod=()=>{}
+        this.helper.removeListeners=(()=>{this.removeAllListeners()}).bind(this.helper)
+        let props={Address: {value:config.mac_address}}
+        this._propsProxy={}
+        this._propsProxy.GetAll=()=>{
+            return props
+        }
+        this._propsProxy.Get=(key)=>{
+            if(key==="Address") 
+                return props.Address 
+            else return null
+        }
+
+        this.intervalID=setInterval(
+            ()=>{
+			adapter.waitDevice(config.mac_address,(config?.discoveryTimeout??30)*1000)
+			.then(async (device)=> { 
+                this.emit("deviceFound", device)
+                clearInterval(this.intervalID)
+                this.intervalID=undefined
+            }).catch((e)=>{
+                
+            })
+            },
+            (config?.discoveryTimeout??30)*1000
+        )
+        
+    }
+    connect(){}
+    disconnect(){}
+    stopListening(){
+        this.removeAllListeners()
+        if (this.intervalID)
+            clearInterval(this.intervalID)
+    }
+}
+module.exports=OutOfRangeDevice

package/README.md

@@ -2,18 +2,26 @@
 
 ## WHAT'S NEW  
 
+# Version 1.2.6-beta
+
+- Mopeka examples not defaults in config
+- Fix so no plugin restart required after selecting sensor class for an unidentified device
+- FeasyCom BP108B support -- iBeacon/Eddystone protocols
+- Ective, Topband, Skanbatt etc LiFePo4 BMS support (ective.de)
+- Fixed Junctek chargeDirection at start (amps will not reported until chargeDirection is known)
+
+# Version 1.2.5-1
+
+- Reverted change from 1.2.5 to path's source field 
+- Victron Sensor model ID and name improvements to constistency for VE Smart Networking enabled devices
+- Improved initial startup responsiveness 
+
 # Version 1.2.5
 
 - On initial startup, plugin saves default configuration. Fixing the "missing" configured devices after restart.
 - Mopeka Tank Sensor configuration fix
 - Added number of found devices in a domain in the configuration screen's domain tab
 
-## IMPORTANT NOTE TO NEW USERS OF VERSIONS OLDER THAN 1.2.5
-
-There's a known issue with saving the configuration after initial installation owing to current ServerAPI limitations.
-
-Your device config after you've saved it will appear to be "missing" after restarting. It's in fact saved in the plugin config directory. All you have to do is Submit the main configuration then enable and optionally disable Debug. This, believe it or not, ensures that the config is marked as enabled. You should see your data now and upon restart. 
-
 # Version 1.2.4-4
 
 Junctek support (tested)
@@ -95,6 +103,8 @@ It's pretty easy to write and deploy your own sensor class for any currently uns
 |[Junctek](https://www.junteks.com)|[Junctek BMS](https://www.junteks.com/pages/product/index) |
 |[Remoran](https://remoran.eu)| [Remoran Wave.3](https://remoran.eu/wave.html)|
 |[AC DC Systems](https://marinedcac.com) | [Bank Manager] hybrid (Pb and Li) charger(https://marinedcac.com/pages/bankmanager)|
+|[Ective](https://ective.de/)| Also Topband(?), Skanbatt and others |
+
 
 ### Environmental 
 | Manufacturer |  Devices | 
@@ -122,7 +132,11 @@ It's pretty easy to write and deploy your own sensor class for any currently uns
 |--------------|----------|
 | [Mercury](https://www.mercurymarine.com)| [Mercury Smartcraft](https://www.mercurymarine.com/us/en/gauges-and-controls/displays/smartcraft-connect) connect engine sensor|
 
+### Beacons
 
+| Manufacturer |  Devices | 
+|--------------|----------|
+|[FeasyCom](https://www.feasycom.com/)| [BP108B](https://www.feasycom.com/product/fsc-bp108b/) |
 
 
 ## WHO IT'S FOR

package/classLoader.js

@@ -27,8 +27,13 @@ const semver = require('semver')
             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);
+                    try{
+                        const cls = require(module.location+module.module+"/"+classFile);
+                        classMap.set(cls.name, cls);
+                    } catch (e) {
+                        console.log(`Unable to load class (${cls.name}): ${e.message}`)
+                        console.log(e)
+                    }
                 })
             })
             classMap.get('UNKNOWN').classMap=new Map([...classMap].sort().filter(([k, v]) => !v.isSystem )) // share the classMap with Unknown for configuration purposes

package/connectUUID.exp

@@ -0,0 +1,26 @@
+#!/usr/bin/expect -f
+
+set device [lindex $argv 0];
+set uuid  [lindex $argv 1];
+set notifies  [lindex $argv 2];
+set timeout 60
+spawn bluetoothctl
+send -- "scan on\r"
+expect $device
+send -- "connect $device\r"
+expect "ServicesResolved: yes"
+send -- "scan off\r"
+expect "Discovering: no"
+send -- "menu gatt\r"
+expect "Menu gatt:"
+send -- "select-attribute $uuid\r"
+expect "service"
+send -- "acquire-notify\r"
+expect "NotifyAcquired: yes"
+for {set i 0} {$i < $notifies} {incr i} {
+    expect "Notification:"
+}
+send -- "back\r"
+expect "Menu main:"
+send -- "disconnect\r"
+expect "disconnected"