bt-sensors-plugin-sk 1.2.1 → 1.2.3

package/BTSensor.js

@@ -465,13 +465,26 @@ class BTSensor extends EventEmitter {
         throw new Error("::initGATTNotifications() should be implemented by the BTSensor subclass")
     }
 
-    deviceConnect() {
+    deviceConnect(reconnect=false) {
 
      
         return connectQueue.enqueue( async ()=>{
             this.debug(`Connecting... ${this.getName()}`)
-            await this.device.connect()
+            await this.device.helper.callMethod('Connect')
+
             this.debug(`Connected to ${this.getName()}`)
+            if (!reconnect) {
+                this.device.helper.on('PropertiesChanged',  (propertiesChanged) => {
+                    if ('Connected' in propertiesChanged) {
+                        const { value } = propertiesChanged.Connected
+                        if (value) {
+                            this.device.emit('connect', { connected: true })
+                        } else {
+                            this.device.emit('disconnect', { connected: false })
+                        }
+                    }
+                })
+            }
 
             try {
 
@@ -787,8 +800,6 @@ class BTSensor extends EventEmitter {
   /**
    *  Listen to sensor.
    *  ::listen() sets up listeners for property changes thru ::propertiesChanged(props)
-   *  If GATT connections are available and active, function inits the GATT connection and 
-   *  optional GATT connection interval
    */
 
 
@@ -842,7 +853,6 @@ class BTSensor extends EventEmitter {
             if (!(path===undefined))
                 this.app.handleMessage(id, 
                 {
-//                $source: source,
                 updates: 
                     [{ meta: [{path: preparePath(this, path), value: { units: pathMeta?.unit }}]}]
                 })

package/README.md

@@ -1,17 +1,17 @@
 # Bluetooth Sensors for [Signal K](http://www.signalk.org) 
-# Version 1.2.0 
+# Version 1.2.3
 
-## WHAT IT IS
+## WHAT'S NEW SINCE VERSION 1.2.2
 
-BT Sensors Plugin for Signalk is a lightweight BLE (Bluetooth Low Energy) framework for listening and connecting to Bluetooth sensors on your boat. After discovery and configuration the plugin sends deltas to Signalk paths with values your sensor reports. <br>
+Bug fixes Remoran Wave.3, JunctekBMS, and ShenzhenLiOn
 
-It runs on any 2.0 or greater SignalK installation but on Linux only. It's been tested on Desktop and headless RPis, OpenPlotter, and Cerbo GX/Ekrano.
+# Version 1.2.2
 
-A typical use case is a Bluetooth thermometer like the Xiaomi LYWSD03MMC, an inexpensive Bluetooth thermometer that runs on a 3V watch battery that can report the current temperature and humidity in your refrigerator or cabin or wherever you want to stick it (no judgement.) <br>
+## WHAT'S NEW SINCE VERSION 1.2.1
 
-The reported temperature can then be displayed on a Signalk app like Kip, WilhelmSK or, with appropriate mapping to NMEA-2000, a NMEA 2000 Multi-function display. 
+- Junctek BMS and Remoran Wave 3 support (Note: both are not currently field tested)
 
-It's pretty easy to write and deploy your own sensor class for any currently unsupported sensor. More on that in [the development README](./sensor_classes/DEVELOPMENT.md).
+- Fixes to ShenzhenLiOn BMS, Victron Orion XS, Victron DC DC Converter, Victron Smart Lithium Classes
 
 ## WHAT'S NEW SINCE VERSION 1.1.x
 
@@ -25,6 +25,19 @@ It's pretty easy to write and deploy your own sensor class for any currently uns
 
 - Support for multiple simultaneous GATT connections. 
 
+
+## WHAT IT IS
+
+BT Sensors Plugin for Signalk is a lightweight BLE (Bluetooth Low Energy) framework for listening and connecting to Bluetooth sensors on your boat. After discovery and configuration the plugin sends deltas to Signalk paths with values your sensor reports. <br>
+
+It runs on any 2.0 or greater SignalK installation but on Linux only. It's been tested on Desktop and headless RPis, OpenPlotter, and Cerbo GX/Ekrano.
+
+A typical use case is a Bluetooth thermometer like the Xiaomi LYWSD03MMC, an inexpensive Bluetooth thermometer that runs on a 3V watch battery that can report the current temperature and humidity in your refrigerator or cabin or wherever you want to stick it (no judgement.) <br>
+
+The reported temperature can then be displayed on a Signalk app like Kip, WilhelmSK or, with appropriate mapping to NMEA-2000, a NMEA 2000 Multi-function display. 
+
+It's pretty easy to write and deploy your own sensor class for any currently unsupported sensor. More on that in [the development README](./sensor_classes/DEVELOPMENT.md).
+
 ## SUPPORTED SENSORS
 
 ### NOTE 
@@ -44,6 +57,8 @@ It's pretty easy to write and deploy your own sensor class for any currently uns
 |Redodo| Rebranded LiTime |
 |Kilovault| [Kilovault HLX+ smart batteries ](https://sunwatts.com/content/manual/KiloVault_HLX_PLUS_Datasheet_06252021%20%281%29.pdf?srsltid=AfmBOooY-cGnC_Qm6V1T9Vg5oZzBCJurS0AOGoWqWeyy-dwz2vA-l1Jb) (Note: Kilovault appears to be out of business as of March 2024) |
 |[Lancol](www.Lancol.com)| [Micro 10C 12V Car Battery Monitor](https://www.lancol.com/product/12v-bluetooth-4-0-battery-tester-micro-10-c/)|
+|[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)|
 
 
 ### Environmental 
@@ -121,6 +136,19 @@ Finally, restart SK. Plugin should appear in your server plugins list.<br>
 > NOTE: "~/.signalk" is the default signalk home on Linux. If you're 
 > getting permissions errors executing npm link, try executing "npm link" under sudo.
 
+## KNOWN ISSUES
+
+### Configuration Panel
+
+- Safari 18.1 on OsX produces errors on load that kill the configuration screen. No known cause. Upgrade to most recent Safari or use Chrome.
+- Unsaved sensor configuration changes are lost after selecting a different sensor. Be sure to Save changes for now.
+- Renogy Rover Client, Victron GX, Victron Smart Battery Protect, and Victron VE Bus sensor classes have no default paths currently. Users will need to manually input.
+
+### Runtime
+
+- IMPORTANT Set `Scan for new devices interval` to `0` after configuration is complete. The plugin will run but in Bluetooth-rich environments, or if you have a long range BT 5.3 device, the system Bluetooth stack may fail after 4 hours or so.
+- There's no way that I know of to remove a SK Path without restarting the server. So if any active paths are changed by the plugin, you'll still see them hanging around in the data browser growing stale until you restart the server.
+
 ## CONFIGURATION
 
 After installing and restarting Signalk you should see a "BT Sensors Plugin" option in the Signalk->Server->Plugin Config page.<br><br>
@@ -266,6 +294,7 @@ Many thanks to all those who contributed to the project either with code or test
 - Arjen
 - SDLee
 - Jordan
+- Jan of SKipper App fame
 
 It takes a village. Or more appropriately, an armada. Okay, regatta. But you get the idea.
   

package/index.js

@@ -172,10 +172,19 @@ module.exports =   function (app) {
 			});
 			router.post('/removeSensorData', async (req, res) => {
 				app.debug(req.body)
+				const sensor = sensorMap.get(req.body.mac_address)
+				if (!sensor) {
+					res.status(404).json({message: "Sensor not found"})
+					return
+				}
 				const i = deviceConfigs.findIndex((p)=>p.mac_address==req.body.mac_address) 
 				if (i>=0){
 					deviceConfigs.splice(i,1)
 				}
+
+				if (sensor.isActive()) 
+					await sensor.stopListening()
+				
 				if (sensorMap.has(req.body.mac_address))
 					sensorMap.delete(req.body.mac_address)
 				app.savePluginOptions(
@@ -569,7 +578,6 @@ module.exports =   function (app) {
 			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)
@@ -578,7 +586,6 @@ module.exports =   function (app) {
 			},1000); 
 			if (progressTimeoutID==null)
 			progressTimeoutID = setTimeout(()=> {
-				app.debug("progress timed out ")
 				if (progressID) {
 
 					clearInterval(progressID);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bt-sensors-plugin-sk",
-  "version": "1.2.1",
-  "description": "Bluetooth Sensors for Signalk -- support for Victron devices, RuuviTag, Xiaomi, ATC and Inkbird, Ultrasonic wind meters, Mopeka tank readers, Renogy Battery and Solar Controllers, Aranet4 environment sensors, SwitchBot temp and humidity sensors, KilovaultHLXPlus smart batteries, and Govee GVH51xx temp sensors",
+  "version": "1.2.3",
+  "description": "Bluetooth Sensors for Signalk - see https://www.npmjs.com/package/bt-sensors-plugin-sk#supported-sensors for a list of supported sensors",
   "main": "index.js",
   "dependencies": {
     "@rjsf/bootstrap-4": "^5.24.11",

package/plugin_defaults.json

@@ -96,6 +96,17 @@
                 "default": "electrical.batteries.{batteryID}.voltage"
             },
             
+            "power":
+            { 
+                "unit": "W",
+                "default": "electrical.batteries.{batteryID}.power"
+            },
+                        
+            "impedance":
+            { 
+                "unit": "Ohm",
+                "default": "electrical.batteries.{batteryID}.impedance"
+            },
             "temperature":{
                 "unit": "K",
                 "default": "electrical.batteries.{batteryID}.temperature"
@@ -107,13 +118,21 @@
 
             "capacity":{
                 "remaining":{
-                    "unit":"Ah",
+                    "unit":"C",
                     "default": "electrical.batteries.{batteryID}.capacity.remaining"
                 },
                 "actual":{
-                    "unit":"Ah",
+                    "unit":"C",
                     "default": "electrical.batteries.{batteryID}.capacity.actual"
                 },
+                "discharge":{
+                    "unit":"KWh",
+                    "default": "electrical.batteries.{batteryID}.capacity.dischargeSinceFull"
+                },
+                "charge":{
+                    "unit":"KWh",
+                    "default": "electrical.batteries.{batteryID}.capacity.totalCharge"
+                },
                 "stateOfCharge":{
                     "unit":"ratio",
                     "default": "electrical.batteries.{batteryID}.capacity.stateOfCharge" 

package/sensor_classes/JBDBMS.js

@@ -52,10 +52,10 @@ class JBDBMS extends BTSensor {
         (buffer)=>{return buffer.readInt16BE(6) / 100} 
       
       this.addDefaultPath('remainingCapacity','electrical.batteries.capacity.remaining')
-        .read=(buffer)=>{return buffer.readUInt16BE(8) / 100} 
+        .read=(buffer)=>{return (buffer.readUInt16BE(8) / 100)*3600} 
       
       this.addDefaultPath('capacity','electrical.batteries.capacity.actual')
-        .read=(buffer)=>{return buffer.readUInt16BE(10) / 100} 
+        .read=(buffer)=>{return (buffer.readUInt16BE(10) / 100)*3600} 
      
       this.addDefaultPath('cycles','electrical.batteries.cycles' )
         .read=(buffer)=>{return buffer.readUInt16BE(12)} 
@@ -139,7 +139,7 @@ class JBDBMS extends BTSensor {
         let datasize = -1
         const timer = setTimeout(() => {
           clearTimeout(timer)
-          reject(new Error(`Response timed out from JBDBMS device ${this.getName()}. `));
+          reject(new Error(`Response timed out (+30s) from JBDBMS device ${this.getName()}. `));
         }, 30000);
 
         const valChanged = async (buffer) => {
@@ -147,13 +147,12 @@ class JBDBMS extends BTSensor {
             if (buffer[0]!==0xDD || buffer.length < 5 || buffer[1] !== command)
                 reject(`Invalid buffer from ${this.getName()}, not processing.`)
             else 
-                datasize=buffer[2]
+                datasize=buffer[3]
           }
           buffer.copy(result,offset)
-          if (buffer[buffer.length-1]==0x77 && offset+buffer.length-6==datasize){
+          if (buffer[buffer.length-1]==0x77 && offset+buffer.length-7==datasize){
             
             result = Uint8Array.prototype.slice.call(result, 0, offset+buffer.length)
-            this.debug(result)
             this.rxChar.removeAllListeners()
             clearTimeout(timer)
             if (!checkSum(result)) 
@@ -196,6 +195,20 @@ async getAndEmitCellVoltages(){
 }
 
 initGATTInterval(){
+  this.device.on("disconnect", ()=>{
+      if (this.isActive()) {
+      this.debug(`Device disconnected. Attempting to reconnect to ${this.getName()}`)  
+          try {        
+          this.deviceConnect(true).then(()=>{
+            this.debug(`Device reconnected -- ${this.getName()}`)  
+          })
+          }
+          catch (e) {
+                  this.debug(`Error while reconnecting to ${this.getName()}`)
+          }
+      }
+  })     
+  this.emitGATT()
   this.initGATTNotifications()
 }
 

package/sensor_classes/Junctek.js

@@ -0,0 +1,148 @@
+
+
+const BTSensor = require("../BTSensor");
+
+function bytesToBase10String(bytes){
+        let s = ""
+        for (let byte of bytes){
+            s+=byte.toString(16)
+        }
+        return s
+    }
+
+class JunctekBMS extends BTSensor{
+    static Domain = BTSensor.SensorDomains.electrical
+    
+    constructor(device, config, gattConfig) {
+        super(device, config, gattConfig)
+    }
+
+    static async identify(device){
+
+        return null
+    }
+
+    hasGATT(){
+        return true
+    }
+
+
+
+    async initSchema(){
+        super.initSchema()
+        this.addDefaultParam("batteryID")
+
+        this.addDefaultPath("voltage","electrical.batteries.voltage")
+            
+        this.addDefaultPath("current","electrical.batteries.current")
+        
+        this.addDefaultPath("power","electrical.batteries.power")
+        
+        this.addDefaultPath("cycles",'electrical.batteries.cycles')
+
+        this.addDefaultPath("soc",'electrical.batteries.capacity.stateOfCharge')
+        this.addDefaultPath("remainingAh",'electrical.batteries.capacity.remaining')
+        this.addDefaultPath("timeRemaining",'electrical.batteries.capacity.timeRemaining')
+        this.addDefaultPath("discharge",'electrical.batteries.capacity.dischargeSinceFull')
+        this.addDefaultPath("charge",'electrical.batteries.capacity.charge')
+        this.addDefaultPath("temperature",'electrical.batteries.temperature')
+        this.addDefaultPath("actualCapacity",'electrical.batteries.capacity.actual')
+        this.addMetadatum('impedance','mOhm', 'measured resistance')
+            .default='electrical.batteries.{batteryID}.impedance'
+    }
+
+    emitFrom(buffer){
+        var value=[], chargeDirection = 1
+
+        for (let byte of buffer){
+            if (byte==0xBB) {
+                value=[]
+                continue
+            }
+            if (byte==0xEE){
+                continue
+            }
+            
+            value.push[byte]
+
+            if (parseInt(byte.toString(16))==NaN){ //not a base-10 number. seriously. that's how Junctek does this.
+                const v = parseInt(bytesToBase10String(value))
+                switch (byte){
+                case 0xC0:{
+                    emit("voltage",v/100)
+                }
+                case 0xC1:{
+                    emit("current",(v/100)*chargeDirection)
+                }
+
+                case 0xD1:{
+                    if (byte==0)
+                        chargeDirection=-1
+                }
+
+                case 0xD2:{
+                    emit("remainingAh",v/1000)
+                }
+
+                case 0xD3:{
+                    emit("discharge",v/100000)
+                }
+                case 0xD4:{
+                    emit("charge",v/100000)
+                }
+                case 0xD6:{
+                    emit("timeRemaining",v*60)
+                }
+                case 0xD7:{
+                    emit("impedance",v/100)
+                }
+                case 0xD8:{
+                    emit("power",(v/100)*chargeDirection)
+                }
+                case 0xD9:{
+                    emit("temperature",v + 173.15) //assume C not F
+                }
+                case 0xB1:{
+                    emit("capacityActual",v /10 )
+                }
+            }
+            }
+        }
+    }
+    emitGATT(){
+        this.battCharacteristic.readValue()
+        .then((buffer)=>{
+            this.emitFrom(buffer)
+        })
+    }
+    initGATTConnection(){ 
+        return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
+            if (!this.gattServer) { 
+                this.gattServer = await this.device.gatt() 
+                this.battService = await this.gattServer.getPrimaryService("0000fff0-0000-1000-8000-00805f9b34fb") 
+                this.battCharacteristic = await this.battService.getCharacteristic("0000ffe1-0000-1000-8000-00805f9b34fb")
+                }
+                resolve(this)
+             }) .catch((e)=>{ reject(e.message) }) }) 
+    }
+
+    initGATTNotifications() { 
+        Promise.resolve(this.battCharacteristic.startNotifications().then(()=>{    
+            this.battCharacteristic.on('valuechanged', buffer => {
+                this.emitFrom(buffer)
+            })
+        }))
+    }
+  
+    async stopListening(){
+        super.stopListening()
+        if (this.battCharacteristic  && await this.battCharacteristic.isNotifying()) {
+            await this.battCharacteristic.stopNotifications()
+            this.battCharacteristic=null
+        }
+        if (await this.device.isConnected()){
+            await this.device.disconnect()
+        }
+    }
+}
+module.exports=JunctekBMS

package/sensor_classes/KilovaultHLXPlus.js

@@ -78,7 +78,7 @@ class KilovaultHLXPlus extends BTSensor{
         this.addDefaultPath("cycles",'electrical.batteries.cycles')
             .read=(buffer)=>{return buffer.readInt16LE(12)}
 
-        this.addDefaultPath("soc",'electrical.batteries.capacity,stateOfCharge')
+        this.addDefaultPath("soc",'electrical.batteries.capacity.stateOfCharge')
             .read=(buffer)=>{return buffer.readInt16LE(14)}
         
         this.addDefaultPath("temperature",'electrical.batteries.temperature')

package/sensor_classes/RemoranWave3.js

@@ -0,0 +1,228 @@
+
+function arduinoDateDecode (elapsedSeconds) {
+    const date = new Date("2000-01-01")
+    date.setTime(date.getTime() + 1000 * elapsedSeconds)
+    return date
+}
+const errors=  {
+                0: "Undefined",
+                1: "Invalid Battery",
+                2: "Overheat",
+                3: "Overheat Shutdown",
+                4: "Generator lead 1 disconnected",
+                5: "Generator lead 2 disconnected",
+                6: "Generator lead 3 disconnected",
+                7: "Short Circuit"
+        }
+
+const eventTypes = {
+            0: "Reboot",
+            1: "Invalid Battery",
+            2: "Overheat",
+            3: "Overheat Shutdown",
+            4: "Generator lead 1 disconnected",
+            5: "Generator lead 2 disconnected",
+            6: "Generator lead 3 disconnected",
+            7: "Short Circuit",
+            255: "Debug"
+        }
+
+const states= ["Charging Needed", "Charging", "Floating", "Idle"]
+
+
+const BTSensor = require("../BTSensor");
+ class RemoranWave3 extends BTSensor{
+    static Domain = BTSensor.SensorDomains.electrical
+    serviceUUID = "81d08df0-c0f8-422a-9d9d-e4379bb1ea3b"
+    info1CharUUID = "62c91222-fafe-4f6e-95f0-afc02bd19f2e"
+    info2CharUUID = "f5d12d34-4390-486c-b906-24ea8906af71"
+    eventUUID =  "f12a8e25-59f7-42f2-b7ae-ba96fb25c13c"
+
+     static async identify(device){
+         
+         const name = await this.getDeviceProp(device,"Name")
+         if (name == 'Remoran Wave.3')
+             return this 
+         else
+             return null
+     }
+     hasGATT(){
+         return true
+     }
+     usingGATT(){
+         return true
+     }
+    emitInfo1Data(buffer){
+        this.debug(`emitting info 1 data`)
+        if (buffer.length < 20) {
+            app.debug(`Bad buffer size ${buffer.length}. Buffer size must be 20 bytes or more.`)
+            return
+        }
+        this.emit("versionNumber", buffer.readUInt8(0))
+        const errors = buffer.readUInt8(2)
+        const errorState = []
+        for (var i = 0; i < 8; ++i) {
+            var c = 1 << i;
+            errors & c && errorState.push(errors[i])
+        }
+        this.emit("errors", errorState)
+        this.emit("state",  states[buffer.readUInt8(3)])
+        this.emit("rpm", buffer.readUInt32LE(4))
+        this.emit( "voltage" , buffer.readFloatLE(8))
+        this.emit("current",  buffer.readFloatLE(12))
+        this.emit( "power", buffer.readFloatLE(16))
+                
+        if (buffer.length > 23) {
+            this.emit( "temp", ((buffer.readFloatLE(20))+273.15))
+            this.emit( "uptime", buffer.readUInt32LE(24))
+            if (versionNumber>1 && buffer.size > 31) {
+                this.emit("energy", buffer.readFloatLE(32))
+            }
+        }
+    
+    }
+    emitInfo2Data(buffer){
+        this.debug(`emitting info 2 data`)
+
+        if (buffer.size < 12) {
+            app.debug(`Bad buffer size ${buffer.length}. Buffer size must be 12 bytes or more.`)
+            return
+         }
+        this.emit("versionNumber", buffer.readUInt8(0))
+        this.emit("temp",  ((buffer.readFloatLE(4))+273.15))
+        this.emit("uptime", buffer.readUInt32LE(8))
+        this.emit("lastBootTime", arduinoDateDecode(buffer.readUInt32LE(12)))
+        this.emit("energy",   buffer.readFloatLE(16))
+    }
+    emitEventData(buffer){
+                this.debug(`emitting event data`)
+        if (buffer.length < 14) {
+            this.debug(buffer)
+            app.debug(`Bad buffer size ${buffer.length}. Buffer size must be 14 bytes or more.`)
+            return
+         }
+        const eventType = buffer.readUInt16LE(8)
+        var eventDesc = eventType.toString()
+        if (Object.hasOwn(eventTypes,eventType))
+            eventDesc = eventTypes[eventType]
+
+
+        this.emit("event", 
+            {
+                firstDate: arduinoDateDecode(buffer.readUInt32LE(0)),
+                lastDate: arduinoDateDecode(buffer.readUInt32LE(4)),
+                eventType: eventType,
+                count: buffer.readUInt16LE(10),
+                index: buffer.readUInt16LE(12),
+                eventDesc: eventDesc
+            }
+        )
+    }
+    emitGATT(){
+        this.info1Characteristic.readValue()
+        .then((buffer)=>
+            this.emitInfo1Data( buffer)
+        )
+        this.info2Characteristic.readValue()
+        .then((buffer)=>
+            this.emitInfo2Data(buffer)  
+        )
+        this.eventCharacteristic.readValue()
+        .then((buffer)=>
+            this.emitEventData(buffer)   
+        )
+
+    }
+     initSchema(){
+        super.initSchema()
+        this.addDefaultParam("id")
+            .default="RemoranWave3"         
+    
+        this.getGATTParams()["useGATT"].default=true
+
+        this.addMetadatum('errorCodes','', 'charger error codes (array)')
+            .default= "electrical.chargers.{id}.errorCodes"
+
+        this.addMetadatum('state','', 'charger state')
+            .default= "electrical.chargers.{id}.state"
+
+        this.addMetadatum('voltage','V', 'battery voltage')
+        .default= "electrical.chargers.{id}.battery.voltage"
+
+        this.addMetadatum('current','A', 'battery current')
+        .default= "electrical.chargers.{id}.battery.current"
+
+        this.addMetadatum('power','W', 'battery power')
+        .default= "electrical.chargers.{id}.battery.power"
+
+        this.addMetadatum('temp', 'K', 'charger temperature')
+        .default= "electrical.chargers.{id}.temperature"
+
+        this.addMetadatum('energy', 'wh', 'energy created today in Wh')
+        .default= "electrical.chargers.{id}.energy"
+
+        this.addMetadatum('event', '', 'charger event')
+        .default= "electrical.chargers.{id}.event"
+
+        this.addMetadatum('lastBootTime', 's', 'last boot time')
+        .default= "electrical.chargers.{id}.lastBootTime"
+
+        this.addMetadatum('rpm', '', 'revolutions per minute')
+        .default= "sensors.{macAndName}.rpm"
+
+        this.addMetadatum('uptime', 's', 'charger/sensor uptime')
+        .default= "sensors.{macAndName}.uptime"
+
+        this.addMetadatum('versionNumber', '', 'charger/sensor version number')
+        .default= "sensors.{macAndName}.version"
+
+    }
+
+ 
+     initGATTConnection(){ 
+         return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
+             if (!this.gattServer) { 
+                 this.gattServer = await this.device.gatt() 
+                 this.service = await this.gattServer.getPrimaryService(this.serviceUUID) 
+                 this.info1Characteristic = await this.service.getCharacteristic(this.info1CharUUID)
+                 this.info2Characteristic = await this.service.getCharacteristic(this.info2CharUUID) 
+                 this.eventCharacteristic = await this.service.getCharacteristic(this.eventUUID)
+                 resolve(this)
+            }}) .catch((e)=>{ this.debug(e); reject(e.message) }) }) 
+     }
+     
+     initGATTNotifications() { 
+         Promise.resolve(this.info1Characteristic.startNotifications().then(()=>{    
+             this.info1Characteristic.on('valuechanged', buffer => {
+                 this.emitInfo1Data(buffer)
+             })
+         }))
+         Promise.resolve(this.info2Characteristic.startNotifications().then(()=>{    
+             this.info2Characteristic.on('valuechanged', buffer => {
+                 this.emitInfo2Data(buffer)
+             })
+         }))
+         Promise.resolve(this.eventCharacteristic.startNotifications().then(()=>{    
+             this.eventCharacteristic.on('valuechanged', buffer => {
+                 this.emitEventData(buffer)
+             })
+         }))
+     }
+    
+    async stopNotifications(characteristic){
+        if (characteristic  && await characteristic.isNotifying()) {
+                await characteristic.stopNotifications()
+        }
+    }
+     async stopListening(){
+        super.stopListening()
+        await this.stopNotifications(this?.info1Characteristic)
+        await this.stopNotifications(this?.info2Characteristic)
+        await this.stopNotifications(this?.eventCharacteristic)
+        if (await this.device.isConnected()){
+            await this.device.disconnect()
+        }
+     }
+ }
+ module.exports=RemoranWave3
+ 

package/sensor_classes/Renogy/RenogyConstants.js

@@ -13,7 +13,8 @@ CHARGING_STATE:
     3: 'Equalizing',
     4: 'Boost',
     5: 'Floating',
-    6: 'Current limiting'
+    6: 'Current limiting',
+    8: 'Not charging'
 },
 
 LOAD_STATE: {

package/sensor_classes/Renogy/RenogySensor.js

@@ -57,9 +57,6 @@ class RenogySensor extends BTSensor{
         ) 
     }
 
-    emitGATT(){
-    }
-
     getModelName(){
         return this?.modelID??`${this.constructor.name} Unknown model` 
     }
@@ -86,7 +83,6 @@ class RenogySensor extends BTSensor{
     }
 
     initGATTInterval(){
-           this.emitGATT()
         this.intervalID = setInterval(()=>{
             this.emitGATT()
         }, 1000*(this?.pollFreq??60) )
@@ -121,7 +117,8 @@ class RenogySensor extends BTSensor{
     async stopListening(){
         super.stopListening()
     
-        await this.readChar.stopNotifications()
+        if (this.readChar)
+            await this.readChar.stopNotifications()
         
         if (await this.device.isConnected()){
             await this.device.disconnect()

package/sensor_classes/RenogyRoverClient.js

@@ -6,53 +6,113 @@ const RenogySensor = require("./Renogy/RenogySensor.js");
 const RC=require("./Renogy/RenogyConstants.js")
 
 class RenogyRoverClient extends RenogySensor {
-
+/*
+          "batteryType": "electrical.charger.battery.type",
+          "batteryPercentage": "electrical.charger.battery.charge",
+          "batteryVoltage": "electrical.charger.battery.voltage",
+          "batteryCurrent": "electrical.charger.battery.current",
+          "controllerTemperature": "electrical.charger.temperature",
+          "batteryTemperature": "electrical.charger.battery.temperature",
+          "loadVoltage": "electrical.charger.load.voltage",
+          "loadCurrent": "electrical.charger.load.current",
+          "loadPower": "electrical.charger.load.power",
+          "pvVoltage": "electrical.charger.solar.voltage",
+          "pvCurrent": "electrical.charger.solar.current",
+          "pvPower": "electrical.charger.solar.power",
+          "maxChargingPowerToday": "electrical.charger.today.max",
+          "maxDischargingPowerToday": "electrical.charger.discharging.maximum",
+          "chargingAmpHoursToday": "electrical.charger.charged.today",
+          "powerGenerationToday": "electrical.charger.power.today",
+          "powerGenerationTotal": "electrical.charger.power.total",
+          "loadStatus": "electrical.charger.load.status",
+          "chargingStatus": "electrical.charger.status"
+*/
 
     initSchema(){
         //Buffer(73) [1, 3, 68, 32, 32, 82, 78, 71, 45, 67, 84, 82, 76, 45, 87, 78, 68, 51, 48, 7, 140, 0, 132, 0, 126, 0, 120, 0, 111, 0, 106, 100, 50, 0, 5, 0, 120, 0, 120, 0, 28, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 5, 0, 5, 2, 148, 0, 5, 206, 143, 34, 228, buffer: ArrayBuffer(8192), byteLength: 73, byteOffset: 6144, length: 73, Symbol(Symbol.toStringTag): 'Uint8Array']
         super.initSchema()
         this.addMetadatum('batteryType', '', "battery type")
+            .default="electrical.chargers.{id}.battery.type"
         this.addMetadatum('batteryPercentage', 'ratio', "battery percentage",
              (buffer)=>{return buffer.readUInt16BE(3) })
+            .default="electrical.chargers.{id}.battery.soc"
+
         this.addMetadatum('batteryVoltage', 'V', "battery voltage",
             (buffer)=>{return buffer.readUInt16BE((5))/10})
+        .default="electrical.chargers.{id}.battery.voltage"
+
         this.addMetadatum('batteryCurrent', 'A', 'battery current',
             (buffer)=>{return buffer.readUInt16BE((7))/100})
+        .default="electrical.chargers.{id}.battery.current"
+
         this.addMetadatum('controllerTemperature', 'K', 'controller temperature',
             (buffer)=>{return buffer.readInt8((9))+273.15})
+        .default="electrical.chargers.{id}.controller.temperature"
+
         this.addMetadatum('batteryTemperature', 'K', 'battery temperature',
             (buffer)=>{return buffer.readInt8((10))+273.15})
+        .default="electrical.chargers.{id}.battery.temperature"
+
         this.addMetadatum('loadVoltage', 'V', 'load voltage',
             (buffer)=>{return buffer.readUInt16BE((11))/10})
+        .default="electrical.chargers.{id}.load.voltage"
+
         this.addMetadatum('loadCurrent',  'A', 'load current',
             (buffer)=>{return buffer.readUInt16BE((13))/100})
+        .default="electrical.chargers.{id}.load.current"
         this.addMetadatum('loadPower', 'W', 'load power',
             (buffer)=>{return buffer.readUInt16BE((15))})
+        .default="electrical.chargers.{id}.load.power"
         this.addMetadatum('pvVoltage', 'V', 'pv voltage',
             (buffer)=>{return buffer.readUInt16BE((17))/10})
+        .default="electrical.chargers.{id}.solar.voltage"
         this.addMetadatum('pvCurrent', 'A', 'pv current',
             (buffer)=>{return buffer.readUInt16BE((19))/100})
+        .default="electrical.chargers.{id}.solar.current"
         this.addMetadatum('pvPower', 'W', 'pv power',
             (buffer)=>{return buffer.readUInt16BE(21)})
+        .default="electrical.chargers.{id}.solar.power"
         this.addMetadatum('maxChargingPowerToday', 'W', 'max charging power today',
             (buffer)=>{return buffer.readUInt16BE(33)})
+        .default="electrical.chargers.{id}.charge.max.today"
         this.addMetadatum('maxDischargingPowerToday', 'W', 'max discharging power today',
             (buffer)=>{return buffer.readUInt16BE(35)})
+        .default="electrical.chargers.{id}.discharge.max.today"
         this.addMetadatum('chargingAmpHoursToday', 'Ah', 'charging amp hours today',
             (buffer)=>{return buffer.readUInt16BE(37)})
+        .default="electrical.chargers.{id}.charge.ampHours.today"
+
         this.addMetadatum('dischargingAmpHoursToday', 'Ah', 'discharging amp hours today',
             (buffer)=>{return buffer.readUInt16BE(39)})
+        .default="electrical.chargers.{id}.discharge.ampHours.today"
+
         this.addMetadatum('powerGenerationToday', 'W', 'power generation today',
             (buffer)=>{return buffer.readUInt16BE(41)})
+        .default="electrical.chargers.{id}.power.generated.today"
+
         this.addMetadatum('powerConsumptionToday', 'W', 'power consumption today',
             (buffer)=>{return buffer.readUInt16BE(43)})
+        .default="electrical.chargers.{id}.power.consumed.today"
+
         this.addMetadatum('powerGenerationTotal', 'W', 'power generation total',
             (buffer)=>{return buffer.readUInt32BE(59)})
+         .default="electrical.chargers.{id}.power.generated.total"
+
         this.addMetadatum('loadStatus', '',  'load status',
             (buffer)=>{return RC.LOAD_STATE[buffer.readUInt8(67)>>7]})
+         .default="electrical.chargers.{id}.load.status"
 
         this.addMetadatum('chargingStatus', '', 'charging status',
-            (buffer)=>{return RC.CHARGING_STATE[buffer.readUInt8(68)]})
+            (buffer)=>{
+                const cs = buffer.readUInt8(68)
+                if (Object.hasOwn(RC.CHARGING_STATE,cs))
+                    return RC.CHARGING_STATE[cs]
+                else
+                    return null
+            })
+
+         .default="electrical.chargers.{id}.charge.status"
+
     }
     
     retrieveDeviceID(){

package/sensor_classes/ShenzhenLiOnBMS.js

@@ -1,6 +1,6 @@
 /**
  * Class to support Batteries with embedded Shenzhen Li-ion Battery Bodyguard Technology BMS 
- * Brands include Redodo, Litime PowerQueen and possibly others
+ * Brands include Redodo, Litime, PowerQueen and possibly others
  */
 
 
@@ -34,19 +34,21 @@ class ShenzhenLiONBMS extends BTSensor{
     static async identify(device){
         return null
     }
+    async sendCommand(cmd){
+        await this.txCharacteristic.writeValueWithResponse( Buffer.from(cmd))
+    }
+
+    async queryBatteryCommand(){
+        await this.sendCommand(this.constructor.Commands.query_battery_status)
+    }
+
     hasGATT(){
         return true
     }
     usingGATT(){
         return true
     }
-    emitGATT(){
-        this.characteristic.readValue()
-        .then((buffer)=>
-            this.emitValuesFrom( buffer)
-        )
 
-    }
      initSchema(){
         super.initSchema()
         this.getGATTParams()["useGATT"].default=true
@@ -82,7 +84,7 @@ class ShenzhenLiONBMS extends BTSensor{
 
         for(let cellNum=0; cellNum < this?.numberOfCells??4; cellNum++) {
             this.addMetadatum(`cell${cellNum+1}Voltage`,'V', `cell #${cellNum+1} voltage`,
-                (buff)=>{return buff.readInt16LE(16+(cellNum*2)) })
+                (buff)=>{return buff.readInt16LE(16+(cellNum*2)) /1000})
             .default=`electrical.batteries.{batteryID}.cells.${cellNum+1}.voltage`
         }
 
@@ -97,11 +99,11 @@ class ShenzhenLiONBMS extends BTSensor{
                 (buff)=>{return buff.readInt16LE(54) + 273.15})
             .default="electrical.batteries.{batteryID}.bms.temperature"
 
-        this.addDefaultPath('remainingAh','electrical.batteries.capacity.remaining')
-            .read=(buff)=>{return this.buff.readUInt16LE(62)/100}
+        this.addDefaultPath('remaining','electrical.batteries.capacity.remaining')
+            .read=(buff)=>{return (buff.readUInt16LE(62)/100)*3600}
 
-        this.addDefaultPath('actualAh','electrical.batteries.capacity.actual')
-            .read=(buff)=>{return this.buff.readUInt16LE(64)/100}
+        this.addDefaultPath('actual','electrical.batteries.capacity.actual')
+            .read=(buff)=>{return (buff.readUInt16LE(64)/100)*3600}
 
         this.addMetadatum('heat','', 'discharge disabled due to app button = 00000080, heater_error = 00000002',
                 (buff)=>{return buff.slice(68,72).reverse().join("")})
@@ -138,7 +140,6 @@ class ShenzhenLiONBMS extends BTSensor{
         this.addDefaultPath( 'soc',"electrical.batteries.capacity.stateOfCharge") 
             .read=(buff)=>{return buff.readUInt16LE(90)/100}
         
-       
         this.getJSONSchema().properties.params.required=["batteryID", "numberOfCells" ]
     }
 
@@ -155,16 +156,25 @@ class ShenzhenLiONBMS extends BTSensor{
             resolve(this)
         })})
     }
+
+    async initGATTInterval(){
+        await this.initGATTNotifications() 
+    }
+
     async initGATTNotifications() { 
-        await this.txCharacteristic.writeValue( Buffer.from(this.constructor.Commands.query_battery_status))
         await this.rxCharacteristic.startNotifications()    
         this.rxCharacteristic.on('valuechanged', buffer => {
                 this.emitValuesFrom(buffer)
         })
+        this.intervalID=setInterval(
+            async ()=>{
+                await this.queryBatteryCommand()
+            }, (this?.pollFreq??10)*1000
+        )    
     }
   
     async stopListening(){
-        super.stopListening()
+        super.stopListening() //clears IntervalID as it happens
         if (this.rxCharacteristic  && await this.rxCharacteristic.isNotifying()) {
             await this.rxCharacteristic.stopNotifications()
             this.rxCharacteristic=null
@@ -174,4 +184,4 @@ class ShenzhenLiONBMS extends BTSensor{
         }
     }
 }
-module.exports=ShenzhenLiONBMS
+module.exports=ShenzhenLiONBMS

package/sensor_classes/Victron/VictronImages.js

@@ -1,6 +1,6 @@
    Images= {
     generic: "victron-min-1.jpg ",
-    shunt: "Victron-SmartShunt.jpg",
+    shunt: "SmartShunt_500_nw.png",
     bmv: "BMV-712-Smart-Front.webp",
     smartSolar: "smartsolarMPPT7515.png"
   }

package/sensor_classes/Victron/VictronSensor.js

@@ -130,10 +130,12 @@ function sleep(x) {
    }
 
    getDescription(){
-    //return `<img src="https://www.victronenergy.com/_next/image?url=https%3A%2F%2Fwww.victronenergy.com%2Fupload%2Fproducts%2FSmartShunt%2520500_nw.png&w=1080&q=70"" height="150" object-fit="cover" ></img>`
+    //return `<img src="https://www.victronenergy.com/_next/image?url=https%3A%2F%2Fwww.victronenergy.com%2Fupload%2Fproducts%2FSmartShunt%2520500_nw.png&w=1080&q=70"" height="150" align=”top” ></img>`
 
 
-    return `<img src="../bt-sensors-plugin-sk/images/${this.getImage()}" height="300" object-fit="cover" ></img>`
+    return `<img src="../bt-sensors-plugin-sk/images/${this.getImage()}" width="200" style="float: left; 
+  margin: 20px;" ></img> 
+    To get the encryption key for your device, follow the instructions <a href=https://communityarchive.victronenergy.com/questions/187303/victron-bluetooth-advertising-protocol.html target="_victron_encrypt">here</a>`
    }
 
 }

package/sensor_classes/VictronBatteryMonitor.js

@@ -56,7 +56,7 @@ class VictronBatteryMonitor extends VictronSensor{
         
         const alarmMD = this.addMetadatum('alarm','',  'alarm', 
                 (buff,offset=0)=>{return buff.readInt16LE(offset)})
-                alarmMD.default='"electrical.batteries.{batteryID}.alarm'                
+                alarmMD.default='electrical.batteries.{batteryID}.alarm'                
                 alarmMD.notify=true
 
         this.addMetadatum( 'consumed','Ah', 'amp-hours consumed', 
@@ -196,7 +196,7 @@ class VictronBatteryMonitor extends VictronSensor{
     }
 
     getDescription(){
-        return super.getDescription()
+        return `${super.getDescription()}.<p><p>After setting the encryption key, Save and reselect to configure the value of the Aux field (Secondary Battery, Midpoint or Battery Temperature)`
     }
 
     async stopListening(){

package/sensor_classes/VictronDCDCConverter.js

@@ -10,7 +10,7 @@ class VictronDCDCConverter extends VictronSensor{
    
     initSchema(){
         super.initSchema()
-        this.addDefaultPath("id")
+        this.addDefaultParam("id")
 
         this.addMetadatum('deviceState','', 'device state', 
                 (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})

package/sensor_classes/VictronLynxSmartBMS.js

@@ -24,9 +24,11 @@ class VictronLynxSmartBMS extends VictronSensor{
 
     initSchema(){
         super.initSchema()
+        this.addDefaultParam("batteryID")
         this.addMetadatum('error','', 'error code', 
             (buff)=>{return buff.readUInt8(0)})
- 
+        .default="electrical.batteries.{batteryID}.errorCode"
+
         this.addDefaultPath('ttg','electrical.batteries.capacity.timeRemaining')
             .read=(buff)=>{return this.NaNif(buff.readUInt16LE(1),0xFFFF)*60}
         this.addDefaultPath('voltage','electrical.batteries.voltage')
@@ -36,10 +38,12 @@ class VictronLynxSmartBMS extends VictronSensor{
         
         this.addMetadatum('ioStatus','','IO Status', //TODO
             (buff)=>{return buff.readUInt16LE(7)})
+        .default="electrical.batteries.{batteryID}.IOStatus"
 
         this.addMetadatum('warningsAndAlarms','','warnings and alarms')
 
         this.addDefaultPath('soc','electrical.batteries.capacity.stateOfCharge')
+        
         this.addMetadatum('consumedAh','Ah','amp-hours consumed')
         .default="electrical.batteries.{batteryID}.capacity.ampHoursConsumed"
         

package/sensor_classes/VictronOrionXS.js

@@ -34,7 +34,7 @@ class VictronOrionXS extends VictronSensor{
             (buff)=>{return this.NaNif(buff.readUInt16LE(8),0xFFFF)/10})
             .default="electrical.chargers.{id}.input.current"
         this.addMetadatum('deviceOffReason','', 'device off reason', 
-            (buff)=>{return VC.OffReasons(buff.readUInt32BE(10))})
+            (buff)=>{return VC.OffReasons.get(buff.readUInt32BE(10))})
             .default="electrical.chargers.{id}.offReason"    
         }
 

package/sensor_classes/VictronSmartLithium.js

@@ -50,7 +50,7 @@ class VictronSmartLithium extends VictronSensor{
             (buff)=>{return buff.readUInt16LE(4)})
             .default="electrical.batteries.{batteryID}.errors"
 
-        for (let i=0;i++;i<8){
+        for (let i=0;i<8; i++){
             this.addMetadatum(`cell${i+1}Voltage`,'V', `cell ${i+1} voltage`)
             .default=`electrical.batteries.{batteryID}.cell${i+1}.voltage`
         }

package/vsl_patch_17_06_25.patch

@@ -0,0 +1,13 @@
+diff --git a/sensor_classes/VictronSmartLithium.js b/sensor_classes/VictronSmartLithium.js
+index 0ed70ad..2988374 100644
+--- a/sensor_classes/VictronSmartLithium.js
++++ b/sensor_classes/VictronSmartLithium.js
+@@ -50,7 +50,7 @@ class VictronSmartLithium extends VictronSensor{
+             (buff)=>{return buff.readUInt16LE(4)})
+             .default="electrical.batteries.{batteryID}.errors"
+ 
+-        for (let i=0;i++;i<8){
++        for (let i=0;i<8; i++){
+             this.addMetadatum(`cell${i+1}Voltage`,'V', `cell ${i+1} voltage`)
+             .default=`electrical.batteries.{batteryID}.cell${i+1}.voltage`
+         }