bt-sensors-plugin-sk 1.2.5-1 → 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,7 +893,7 @@ 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 }}]}]
                 })
             }
         })
@@ -904,7 +905,7 @@ class BTSensor extends EventEmitter {
             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 )
@@ -923,8 +924,43 @@ class BTSensor extends EventEmitter {
     }
 
     prepareConfig(config){
-        config.params.sensorClass=this.constructor.name
+        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,6 +2,14 @@
 
 ## 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 
@@ -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"