bt-sensors-plugin-sk 1.1.0-beta.2.1.4.4 → 1.1.0-beta.2.2.0

package/BTSensor.js

@@ -606,7 +606,7 @@ class BTSensor extends EventEmitter {
     NaNif(v1,v2) {  return this.constructor.NaNif(v1,v2) }
 
     valueIfVariant(obj){
-        if (obj.constructor && obj.constructor.name=='Variant') 
+        if (obj?.constructor && obj.constructor.name=='Variant') 
             return obj.value
         else
             return obj

package/README.md

@@ -1,5 +1,16 @@
 # Bluetooth Sensors for [Signal K](http://www.signalk.org)
 
+## BETA 2.2.0
+
+### What's New
+Support for Aranet4 environment sensor and Renogy Rover/Wanderer Controllers. Untested support for Renogy Battery and Inverter clients. If you have a Renogy Battery or Inverter with bluetooth support, please give it a try and let me know how it goes. 
+
+### RENOGY NOTES 
+
+The class of Renogy Devices cannot be reliably identified from their Bluetooth advertisements. <br>
+
+On the plugin config page, You will need to select the device from the Device dropdown, then select the appropriate class from the Class dropdown. After that, you will need to hit the Submit button. On restart of the plugin, the plugin should recognize the device. If you've selected the appropriate class (RenogyRoverClient for example), you should see configs for paths. <br>
+
 
 ## WHAT IT IS
 

package/index.js

@@ -1,9 +1,11 @@
 const fs = require('fs')
 const util = require('util')
 const path = require('path')
+const packageInfo = require("./package.json")
+
 const {createBluetooth} = require('node-ble')
 const {bluetooth, destroy} = createBluetooth()
-const packageInfo = require("./package.json")
+
 const BTSensor = require('./BTSensor.js')
 const BLACKLISTED = require('./sensor_classes/BlackListedDevice.js')
 
@@ -109,8 +111,17 @@ module.exports =  function (app) {
 			app.setPluginError(msg)
 		}
 		//if we're here ain't got no class for the device
-		const sensor = new (classMap.get('UNKNOWN'))(device)
-		await sensor.init()
+		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
 	}
 
@@ -149,7 +160,10 @@ module.exports =  function (app) {
   	}  
 
 	function loadClassMap() {
-		classMap = utilities_sk.loadClasses(path.join(__dirname, 'sensor_classes'))
+		const _classMap = utilities_sk.loadClasses(path.join(__dirname, 'sensor_classes'))
+		classMap = new Map([..._classMap].filter(([k, v]) => !k.startsWith("_") ))
+		classMap.get('UNKNOWN').classMap=new Map([...classMap].filter(([k, v]) => !v.isSystem )) // share the classMap with Unknown for configuration purposes
+
 	}
 
 	app.debug(`Loading plugin ${packageInfo.version}`)
@@ -308,8 +322,10 @@ module.exports =  function (app) {
 		})
 		.catch((e)=>{
 			if (s)
-				s.stopListening()		
+				s.stopListening()
+
 			app.debug(`Unable to communicate with device ${deviceNameAndAddress(config)} Reason: ${e?.message??e}`)
+			app.debug(e)
 			reject( e?.message??e )	
 		})})
 	}
@@ -410,11 +426,11 @@ module.exports =  function (app) {
 		adapter = await bluetooth.getAdapter(app.settings?.btAdapter??adapterID)
 		await startScanner()
 		if (starts>0){
-			app.debug('Plugin restarting...');
+			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 build Beta 2.4.1.2 started');
+			app.debug(`Plugin ${packageInfo.version} started` )
 			
 		}
 		starts++

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bt-sensors-plugin-sk",
-  "version": "1.1.0-beta.2.1.4.4",
-  "description": "Bluetooth Sensors for Signalk -- support for Victron devices, RuuviTag, Xiaomi, ATC and Inkbird, Ultrasonic, Mopeka tank reader and preliminary support for Govee GVH51xx temp sensors",
+  "version": "1.1.0-beta.2.2.0",
+  "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 (new), Aranet4 environment sensors, and Govee GVH51xx temp sensors",
   "main": "index.js",
   "dependencies": {
     "dbus-next": "^0.10.2",

package/sensor_classes/Aranet/AranetSensor.js

@@ -0,0 +1,24 @@
+const BTSensor = require("../../BTSensor");
+class AranetSensor extends BTSensor{
+    COLOR = {
+        1: 'Green',
+        2: 'Yellow',
+        3: 'Red'
+    }
+    
+    constructor(device, config={}){
+        super(device, config)
+    }
+
+    static async identify(device){
+        const md  = await this.getDeviceProp(device,"ManufacturerData")
+    
+        if (md && md[0x0702]) {
+            return this
+        }
+        
+        return null
+    }
+  
+}
+module.exports=AranetSensor

package/sensor_classes/Aranet2.js

@@ -0,0 +1,47 @@
+const AranetSensor = require("./Aranet/AranetSensor");
+class Aranet2 extends AranetSensor{
+    
+    constructor(device, config={}){
+        super(device,config)
+    }
+    static async identify(device){
+        const name = await this.getDeviceProp(device,"Name")
+        
+        if ((await super.identify(device)!=null) && 
+            name.toLowerCase().startsWith("aranet2")) {
+            console.log("Aranet2 not currently supported")
+            return null //not supported for now
+        }
+    }
+    async init() {
+        await super.init()
+        this.initMetadata()
+    }
+
+    initMetadata(){
+            this.addMetadatum('c02', '',  'c02 concentration',
+                (buff)=>{return ((buff.readUInt16LE(8)))})
+            this.addMetadatum('temp','K', 'temperature',
+                (buff)=>{return parseFloat((273.15+(buff.readInt16LBE(15))/1000).toFixed(2))})
+
+            this.addMetadatum("pressure","","atmospheric pressure", 
+                (buff)=>{return ((buff.readUInt16LE(13)))/10})
+            this.addMetadatum('batteryStrength', 'ratio',  'sensor battery strength',
+                (buff)=>{return ((buff.readUInt8(12))/100)})
+
+            this.addMetadatum('humidity','ratio', 'humidity',
+                (buff)=>{return ((buff.readUInt16LE(8))/10000)})
+        
+    }
+    propertiesChanged(props){
+        super.propertiesChanged(props)    
+        const buff = this.getManufacturerData(0x0702)
+        this.emitData("temp", buff)
+        this.emitData("humidity", buff)
+        this.emitData("pressure", buff)
+        this.emitData("batteryStrength", buff)
+        
+    }                    
+
+}
+module.exports=Aranet2

package/sensor_classes/Aranet4.js

@@ -0,0 +1,53 @@
+const AranetSensor = require("./Aranet/AranetSensor");
+class Aranet4 extends AranetSensor{
+    
+    constructor(device, config={}){
+        super(device,config)
+    }
+
+    static async identify(device){
+        const name = await this.getDeviceProp(device,"Name")
+        
+        if ((await super.identify(device) != null) && 
+            name.toLowerCase().startsWith("aranet4")) {
+            return this
+        }
+        return null
+    }
+    
+    async init() {
+        await super.init()
+        this.initMetadata()
+    }
+
+    initMetadata(){
+            this.addMetadatum('co2', 'ppm',  'co2 concentration',
+                (buff)=>{return ((buff.readUInt16LE(8)))})
+            this.addMetadatum('temp','K', 'temperature',
+                (buff)=>{return parseFloat((273.15+(buff.readInt16LE(10))/20).toFixed(2))})
+
+            this.addMetadatum("pressure","hPa","atmospheric pressure", 
+                (buff)=>{return ((buff.readUInt16LE(12)))/10})
+
+            this.addMetadatum('humidity','ratio', 'humidity',
+                (buff)=>{return ((buff.readUInt8(14))/100)})
+            this.addMetadatum('batteryStrength', 'ratio',  'sensor battery strength',
+                (buff)=>{return ((buff.readUInt8(15))/100)})
+            this.addMetadatum('color', '',  'Warning color (G Y R)',
+                (buff)=>{return this.COLOR[buff.readUInt8(16)]})
+            
+    }
+    propertiesChanged(props){
+        super.propertiesChanged(props)    
+        const buff = this.getManufacturerData(0x0702)
+        this.emitData("co2", buff)
+        this.emitData("temp", buff)
+        this.emitData("humidity", buff)
+        this.emitData("pressure", buff)
+        this.emitData("batteryStrength", buff)
+        this.emitData("color", buff)
+        
+    }                    
+
+}
+module.exports=Aranet4

package/sensor_classes/BlackListedDevice.js

@@ -1,5 +1,6 @@
 const BTSensor = require("../BTSensor");
 class BLACKLISTED extends BTSensor{
+    static isSystem = true
     static async identify(device){
         if (await this.getManufacturerID(device)===0x004C)   //apple devices use 
             return this                                     //randomised macs and clog up our list

package/sensor_classes/Renogy/CRC.js

@@ -0,0 +1,51 @@
+const CRC16_LOW_BYTES = [
+    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04,
+    0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8,
+    0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
+    0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10,
+    0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
+    0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
+    0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C,
+    0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0,
+    0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
+    0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
+    0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C,
+    0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
+    0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54,
+    0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98,
+    0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
+    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40
+]
+
+const CRC16_HIGH_BYTES = [
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
+]
+
+// Calculate CRC-16 for Modbus
+function crc16Modbus(data){
+    var crc_high = 0xFF
+    var crc_low = 0xFF
+
+    for (const byte of data){
+        const index = crc_high ^ byte
+        crc_high = crc_low ^ CRC16_HIGH_BYTES[index]
+        crc_low = CRC16_LOW_BYTES[index]
+    }
+    return Buffer.from([crc_high, crc_low]).readUInt16BE()
+}
+module.exports = crc16Modbus

package/sensor_classes/Renogy/RenogyConstants.js

@@ -0,0 +1,32 @@
+RENOGY_CONSTANTS={
+    FUNCTION:
+    {
+        3: "READ",
+        6: "WRITE"
+    },
+
+CHARGING_STATE:
+ {
+    0: 'Deactivated',
+    1: 'Activated',
+    2: 'MPPT',
+    3: 'Equalizing',
+    4: 'Boost',
+    5: 'Floating',
+    6: 'Current limiting'
+},
+
+LOAD_STATE: {
+  0: 'Off',
+  1: 'On'
+},
+
+BATTERY_TYPE: {
+    1: 'Flooded/Open',
+    2: 'Sealed',
+    3: 'Gel',
+    4: 'Lithium',
+    5: 'Custom'
+}
+}
+module.exports=RENOGY_CONSTANTS

package/sensor_classes/Renogy/RenogySensor.js

@@ -1,107 +1,122 @@
+/*
+ported from https://github.com/cyrils/renogy-bt
+*/
 const BTSensor = require("../../BTSensor.js");
 const VC = require('./RenogyConstants.js');
-function sleep(x) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(x);
-      }, x);
-    });
-  }
-  class RenogySensor extends BTSensor{
+const crc16Modbus = require('./CRC.js')
+class RenogySensor extends BTSensor{
 
+    static ALIAS_PREFIX = 'BT-TH'
+    static TX_SERVICE = "0000ffd0-0000-1000-8000-00805f9b34fb"
+    static RX_SERVICE = "0000fff0-0000-1000-8000-00805f9b34fb"  
+    static NOTIFY_CHAR_UUID = "0000fff1-0000-1000-8000-00805f9b34fb"
+    static WRITE_CHAR_UUID  = "0000ffd1-0000-1000-8000-00805f9b34fb"
+    static READ_FUNC = 3
+    static WRITE_FUNC = 6
     constructor(device,config,gattConfig){
         super(device,config,gattConfig)
-        this.encryptionKey = config?.encryptionKey
     }
+    static async getReadWriteCharacteristics(device){
+        const gattServer = await device.gatt()
+        const txService= await gattServer.getPrimaryService(this.TX_SERVICE)
+        const rxService= await gattServer.getPrimaryService(this.RX_SERVICE)
+        const rxChar = await rxService.getCharacteristic(this.NOTIFY_CHAR_UUID)
+        const txChar = await txService.getCharacteristic(this.WRITE_CHAR_UUID)
+        return {read: rxChar, write: txChar}
+    }
+
+    static async sendReadFunctionRequest(writeCharacteristic, deviceID, writeReq, words){
+        var b = Buffer.alloc(8)
+        b.writeUInt8(deviceID,0)
+        b.writeUInt8(this.READ_FUNC,1)
+        b.writeUInt16BE(writeReq,2)
+        b.writeUInt16BE(words,4) 
+        b.writeUInt16BE(crc16Modbus(b.subarray(0,6)),6)          
+        
+        await writeCharacteristic.writeValueWithResponse(b,  0)
     
-    static async identifyMode(device, mode){
-            
-        var md = await this.getDeviceProp(device,'ManufacturerData')
-        if (md==undefined || !Object.hasOwn(md,0x2e1)) 
-            return null
-        else {
-            
-            if (md[0x2e1].value[0]==0x10) {
-                if (md[0x2e1].value[4]==mode)
-                    return this
-                else 
-                    return null
-            }
-
-            var hasDataPacket=false
-            device.helper._prepare()
-            device.helper.on("PropertiesChanged",
-                 (props)=> {
-                    if (Object.hasOwn(props,'ManufacturerData')){
-                        md = props['ManufacturerData'].value
-                        hasDataPacket=md[0x2e1].value[0]==0x10
-                    }
-            })        
-            while (!hasDataPacket) {
-                await sleep(500)
-            }
-            device.helper.removeListeners()
-            if (md[0x2e1].value[4]==mode)
-                return this
-            else
-                return null
-        } 
+    }
+    static identify(device){
+        return null
     }
 
     async init(){
         await super.init()
-    }
-    alarmReason(alarmValue){
-        return this.constructor.AlarmReason[alarmValue]
-    }
-    getModelName(){
-        return VC?.MODEL_ID_MAP[this.model_id]??this.constructor.name+" (Model ID:"+this.model_id+")"
-    }
+        var md = this.addMetadatum('refreshInterval','','refresh interval')
+        md.isParam = true
 
-    decrypt(data){
-        if (!this.encryptionKey)
-            throw Error("Unable to decrypt: no encryption key set")
+        md = this.addMetadatum('deviceID', '', 'ID of device')
+        md.isParam = true
 
-        const encMethod = 'aes-128-ctr';
-        const iv = data.readUInt16LE(5); 
-        const key = Buffer.from(this.encryptionKey,'hex')
-        const ivBuffer = Buffer.alloc(16); // 128 bits = 16 bytes
-        
-        ivBuffer.writeUInt16LE(iv)
-        
-        var encData = Buffer.from([...data.slice(8)])
-        
-        const decipher = crypto.createDecipheriv(encMethod, key, ivBuffer)
-        
-        const decData=decipher.update(encData)
+        await this.device.connect()
+        const rw = await this.constructor.getReadWriteCharacteristics(this.device)
 
-        return Buffer.from(decData)
+        this.readChar = rw.read    
+        this.writeChar = rw.write
+        await this.readChar.startNotifications()
         
     }
+
+    emitGATT(){
+    }
+
+    getModelName(){
+        return this?.modelID??`${this.constructor.name} Unknown model` 
+    }
+
     getName(){
-        return `Victron ${this.getModelName()}`
+        return `Renogy ${this.getModelName()}`
     }
     propertiesChanged(props){
         super.propertiesChanged(props)
-        if (this.usingGATT()) return
-        
-        try{
-            const md = this.getManufacturerData(0x2e1)
-            if (md && md.length && md[0]==0x10){
-                const decData=this.decrypt(md)
-                this.emitValuesFrom(decData)
-            }
-        }
-        catch (error) {
-            throw new Error(`Unable to read data from ${ this.getDisplayName()}: ${error}` )
-        }
     }
 
-    initGATTConnection(){
-        throw new Error( "GATT Connection unimplemented for "+this.getDisplayName())
+    getAllEmitterFunctions(){
+        return []
+    }
+
+    getDeviceID()
+    {
+        return this?.deviceID??0xFF
+    }
+
+    async sendReadFunctionRequest(writeReq, words){
+        this.constructor.sendReadFunctionRequest(
+            this.writeChar, this.getDeviceID(), writeReq, words) 
+    }
+
+    async initGATTNotifications(){
+        this.getAllEmitterFunctions().forEach(async (emitter)=>
+            await emitter()
+        )
+        this.intervalID = setInterval(()=>{
+            this.getAllEmitterFunctions().forEach(async (emitter)=>
+                await emitter()
+            )
+        }, 1000*(this?.refreshInterval??60) )
     }
 
-   
+
+    async initGATTConnection() {
+        return this  
+    }
+    usingGATT(){
+        return true
+    }
+    hasGATT(){
+        return false
+    }
+
+    async stopListening(){
+        super.stopListening()
+    
+        await this.readChar.stopNotifications()
+        
+        if (await this.device.isConnected()){
+            await this.device.disconnect()
+            this.debug(`Disconnected from ${ this.getName()}`)
+        }
+    }
 
 }
 module.exports=RenogySensor

package/sensor_classes/RenogyBattery.js

@@ -0,0 +1,114 @@
+/**
+  
+ */
+
+const RenogySensor = require("./Renogy/RenogySensor.js");
+class RenogyBattery extends RenogySensor {
+    
+    
+  
+    async init(){
+        await super.init()
+        this.numberOfCells = await this.retrieveNumberOfCells()
+        this.deviceID = await this.retrieveDeviceID()
+        this.initMetadata()
+    }
+
+    async getAllEmitterFunctions(){
+        return [this.getAndEmitBatteryInfo.bind(this), 
+                this.getAndEmitCellTemperatures.bind(this), 
+                this.getAndEmitCellVoltages.bind(this)]
+    }
+    initMetadata(){
+
+        this.addMetadatum('numberOfCells','', 'number of cells')
+        this.addMetadatum('current','A','current',
+             (buffer)=>{return buffer.readInt16BE(3)/100})
+             
+        this.addMetadatum('voltage','V','voltage',
+            (buffer)=>{return buffer.readUInt16BE(5)/10})
+        
+        this.addMetadatum('remainingCharge', 'Ah', 'remaining charge',  //TODO: units 
+            (buffer)=>{return buffer.readUInt32BE(7)/1000})
+
+        this.addMetadatum('capacity','Ah', 'capacity',
+            (buffer)=>{return buffer.readUInt32BE(11)/1000})
+
+        for (let i = 0; i++ ; i < this.numberOfCells) {
+            this.addMetadatum(`cellVoltage${i}`, 'V', `cell #${i} voltage`,
+                (buffer)=>{ return buffer.readUInt16(5+ i*2) }
+            )
+            this.addMetadatum(`cellTemp${i}`, 'K', `cell #${i} temperature`,
+                (buffer)=>{ return buffer.readUInt16(5+ i*2)+273.15 }
+            )
+        }
+    }
+    async initGATTConnection() {
+        await super.initGATTConnection()
+        this.emit('numberOfCells', this.numberOfCells)
+    }
+    
+    retrieveNumberOfCells(){
+
+        return new Promise( async ( resolve, reject )=>{
+            await this.sendReadFunctionRequest(0x1388,0x11)
+
+            const valChanged = async (buffer) => {
+                resolve(buffer.readUInt16(3))
+            }
+            this.readChar.once('valuechanged', valChanged )
+        })
+    }
+    retrieveDeviceID(){
+        return new Promise( async ( resolve, reject )=>{
+            this.sendFunctionRequest(0x14, 0x67)
+
+            const valChanged = async (buffer) => {
+                resolve((buffer.readUInt8(4)))
+            }
+            this.readChar.once('valuechanged', valChanged )
+        })
+    }
+
+    getAndEmitBatteryInfo(){
+        return new Promise( async ( resolve, reject )=>{
+
+            await this.sendReadFunctionRequest(0x13b2, 0x6)
+
+        
+            this.readChar.once('valuechanged', (buffer) => {
+                ["current", "voltage", "remainingCharge", "capacity"].forEach(tag)
+                    this.emitData( tag, buffer )
+                
+                resolve(this)
+            })
+        })
+    }
+    
+    getAndEmitCellVoltages(){
+        return new Promise( async ( resolve, reject )=>{
+            this.sendReadFunctionRequest(0x1388,0x11)
+
+            this.readChar.once('valuechanged', (buffer) => {
+                for (let i = 0; i++ ; i < this.numberOfCells) 
+                    this.emitData(`cellVoltage${i}`, buffer)
+                resolve(this)
+            })
+        })
+    }
+
+    getAndEmitCellTemperatures(){
+        return new Promise( async ( resolve, reject )=>{
+            this.sendReadFunctionRequest(0x1399,0x22)
+
+            this.readChar.once('valuechanged', buffer => {
+                for (let i = 0; i++ ; i < this.numberOfCells) 
+                    this.emitData(`cellTemp${i}`, buffer)
+                resolve(this)
+            })
+        })
+    }
+
+  
+}
+module.exports=RenogyBattery

package/sensor_classes/RenogyInverter.js

@@ -0,0 +1,113 @@
+/**
+  
+ */
+
+const RenogySensor = require("./Renogy/RenogySensor.js");
+const RC=require("./Renogy/RenogyConstants.js")
+class RenogyInverter extends RenogySensor {
+
+    
+    async init(){
+        await super.init()
+        this.initMetadata()
+    }
+
+    initMetadata(){
+        this.addMetadatum('batteryType', '', "battery type")
+    
+        this.addMetadatum('ueiVoltage','V','UEI Voltage',
+            (buffer)=>{return buffer.readUInt16BE(3)/10})
+        this.addMetadatum('ueiCurrent','V','UEI current',
+            (buffer)=>{return buffer.readUInt16BE(5)/10})
+        this.addMetadatum('voltage','V','voltage',
+            (buffer)=>{return buffer.readUInt16BE(7)/10}) 
+        this.addMetadatum('loadCurrent','A','load current',
+            (buffer)=>{return buffer.readUInt16BE(9)})
+        this.addMetadatum('frequency','hz','frequency',
+            (buffer)=>{return buffer.readUInt16BE(11)/100})
+        this.addMetadatum('temperature','K','temperature',
+            (buffer)=>{return (buffer.readUInt16BE(13)/10)+273.15})
+
+        this.addMetadatum('solarVoltage','V', 'solar voltage',
+            (buffer)=>{return buffer.readUInt16BE(3)/10})
+        this.addMetadatum('solarCurrent','A', 'solar current',
+            (buffer)=>{return buffer.readUInt16BE(5)/10})
+        this.addMetadatum('solarPower','W', 'solar power',
+            (buffer)=>{return buffer.readUInt16BE(7)})
+        this.addMetadatum('solarChargingStatus', '', 'solar charging state',
+            (buffer)=>{return RC.CHARGING_STATE[buffer.readUInt16BE(9)]})
+        this.addMetadatum('solarChargingPower', 'W', 'solar charging power',
+            (buffer)=>{return buffer.readUInt16BE(11)})
+
+        this.addMetadatum('loadPower','W','load power',
+            (buffer)=>{return buffer.readUInt16BE(3)})
+        this.addMetadatum('chargingCurrent','A','charging current',
+            (buffer)=>{return buffer.readUInt16BE(5)/10})
+            
+        }
+    
+    getBatteryType(){
+        return new Promise( async ( resolve, reject )=>{
+            this.sendReadFunctionRequest( 0xe004, 0x01)
+
+            const valChanged = async (buffer) => {
+                resolve(RC.BATTERY_TYPE[(buffer.readUInt8(4))])
+            }
+            this.readChar.once('valuechanged', valChanged )
+        })
+    }
+
+    getAndEmitInverterStats(){
+        return new Promise( async ( resolve, reject )=>{
+
+            await this.sendReadFunctionRequest(0xfa0, 0x8)
+        
+            this.readChar.once('valuechanged', (buffer) => {
+                ["ueiVoltage","ueiCurrent", "voltage", "loadCurrent", "frequency","temperature"].forEach(tag)
+                    this.emitData( tag, buffer )
+                
+                resolve(this)
+            })
+        })
+    }
+
+    getAndEmitSolarCharging(){
+        return new Promise( async ( resolve, reject )=>{
+
+            await this.sendReadFunctionRequest(0x10e9, 0x5)
+        
+            this.readChar.once('valuechanged', (buffer) => {
+                ["solarVoltage","solarCurrent", "solarPower", "solarChargingStatus", "solarChargingPower"].forEach(tag)
+                    this.emitData( tag, buffer )
+                
+                resolve(this)
+            })
+        })
+    }
+
+    getAndEmitInverterLoad(){
+        return new Promise( async ( resolve, reject )=>{
+            
+            await this.sendReadFunctionRequest(0x113a, 0x2)
+        
+            this.readChar.once('valuechanged', (buffer) => {
+                ["loadPower", "chargingCurrent"].forEach(tag)
+                    this.emitData( tag, buffer )
+                
+                resolve(this)
+            })
+        })
+    }
+    getAllEmitterFunctions(){
+        return [
+            this.getAndEmitInverterLoad.bind(this), 
+            this.getAndEmitInverterStats.bind(this), 
+            this.getAndEmitSolarCharging.bind(this)]
+    }
+    async initGATTConnection() {
+        await super.initGATTConnection()
+        this.batteryType = await this.getBatteryType()
+        this.emit('batteryType', this.batteryType)
+    }
+}
+module.exports=RenogyInverter

package/sensor_classes/RenogyRoverClient.js

@@ -0,0 +1,133 @@
+/**
+  
+ */
+
+const RenogySensor = require("./Renogy/RenogySensor.js");
+const RC=require("./Renogy/RenogyConstants.js")
+const crc16Modbus = require('./Renogy/CRC.js')
+
+class RenogyRoverClient extends RenogySensor {
+
+    async init(){
+        await super.init()
+        this.initMetadata()
+        this.modelID=await this.retrieveModelID()
+    }
+
+    initMetadata(){
+        //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']
+
+        this.addMetadatum('batteryType', '', "battery type")
+        this.addMetadatum('batteryPercentage', 'ratio', "battery percentage",
+             (buffer)=>{return buffer.readUInt16BE(3) })
+        this.addMetadatum('batteryVoltage', 'V', "battery voltage",
+            (buffer)=>{return buffer.readUInt16BE((5))/10})
+        this.addMetadatum('batteryCurrent', 'A', 'battery current',
+            (buffer)=>{return buffer.readUInt16BE((7))/100})
+        this.addMetadatum('controllerTemperature', 'K', 'controller temperature',
+            (buffer)=>{return buffer.readInt8((9))+273.15})
+        this.addMetadatum('batteryTemperature', 'K', 'battery temperature',
+            (buffer)=>{return buffer.readInt8((10))+273.15})
+        this.addMetadatum('loadVoltage', 'V', 'load voltage',
+            (buffer)=>{return buffer.readUInt16BE((11))/10})
+        this.addMetadatum('loadCurrent',  'A', 'load current',
+            (buffer)=>{return buffer.readUInt16BE((13))/100})
+        this.addMetadatum('loadPower', 'W', 'load power',
+            (buffer)=>{return buffer.readUInt16BE((15))})
+        this.addMetadatum('pvVoltage', 'V', 'pv voltage',
+            (buffer)=>{return buffer.readUInt16BE((17))/10})
+        this.addMetadatum('pvCurrent', 'A', 'pv current',
+            (buffer)=>{return buffer.readUInt16BE((19))/100})
+        this.addMetadatum('pvPower', 'W', 'pv power',
+            (buffer)=>{return buffer.readUInt16BE(21)})
+        this.addMetadatum('maxChargingPowerToday', 'W', 'max charging power today',
+            (buffer)=>{return buffer.readUInt16BE(33)})
+        this.addMetadatum('maxDischargingPowerToday', 'W', 'max discharging power today',
+            (buffer)=>{return buffer.readUInt16BE(35)})
+        this.addMetadatum('chargingAmpHoursToday', 'Ah', 'charging amp hours today',
+            (buffer)=>{return buffer.readUInt16BE(37)})
+        this.addMetadatum('dischargingAmpHoursToday', 'Ah', 'discharging amp hours today',
+            (buffer)=>{return buffer.readUInt16BE(39)})
+        this.addMetadatum('powerGenerationToday', 'W', 'power generation today',
+            (buffer)=>{return buffer.readUInt16BE(41)})
+        this.addMetadatum('powerConsumptionToday', 'W', 'power consumption today',
+            (buffer)=>{return buffer.readUInt16BE(43)})
+        this.addMetadatum('powerGenerationTotal', 'W', 'power generation total',
+            (buffer)=>{return buffer.readUInt32BE(59)})
+        this.addMetadatum('loadStatus', '',  'load status',
+            (buffer)=>{return RC.LOAD_STATE[buffer.readUInt8(67)>>7]})
+
+        this.addMetadatum('chargingStatus', '', 'charging status',
+            (buffer)=>{return RC.CHARGING_STATE[buffer.readUInt8(68)]})
+    }
+    
+    retrieveDeviceID(){
+        return new Promise( async ( resolve, reject )=>{
+            this.sendReadFunctionRequest(0x1A, 0x1)
+
+            const valChanged = async (buffer) => {
+                resolve((buffer.readUInt8(4)))
+            }
+            this.readChar.once('valuechanged', valChanged )
+        })
+    }
+
+    retrieveBatteryType(){
+        return new Promise( async ( resolve, reject )=>{
+        //Buffer(7) [255, 3, 2, 0, 1, 80, 80, buffer: ArrayBuffer(8192), byteLength: 7, byteOffset: 864, length: 7, Symbol(Symbol.toStringTag): 'Uint8Array']
+
+            this.sendReadFunctionRequest(0xe004, 0x01)
+
+            const valChanged = async (buffer) => {
+                resolve(RC.BATTERY_TYPE[(buffer.readUInt8(4))])
+            }
+            this.readChar.once('valuechanged', valChanged )
+        })
+    }
+
+
+    async retrieveModelID(){
+        return new Promise( async ( resolve, reject )=>{
+
+        await this.sendReadFunctionRequest(0x0c,0x08)
+          
+        this.readChar.once('valuechanged', async (buffer) => {
+            if (buffer[2]!=0x10) 
+                reject("Unknown error retrieving model ID") //???
+            const model = buffer.subarray(3,17).toString().trim()
+            resolve(model)           
+        })
+    })
+    }
+    async initGATTConnection() {
+        await super.initGATTConnection()
+        this.batteryType = await this.retrieveBatteryType()
+        this.emit('batteryType', this.batteryType)
+        if (!this.deviceID)
+            this.deviceID = await this.retrieveDeviceID()
+        
+    }
+
+
+    getAllEmitterFunctions(){
+        return [this.getAndEmitChargeInfo.bind(this)]
+    }
+
+    async getAndEmitChargeInfo(){
+        return new Promise( async ( resolve, reject )=>{
+            try {
+                this.sendReadFunctionRequest(0x100, 0x22)
+
+                this.readChar.once('valuechanged', buffer => {
+                    this.emitValuesFrom(buffer)
+                    resolve(this)
+                })
+                                
+            } catch (error) {
+                reject(error?.message??error)
+            }
+        })
+    }
+    
+}
+module.exports=RenogyRoverClient

package/sensor_classes/UNKNOWN.js

@@ -1,5 +1,7 @@
 const BTSensor = require("../BTSensor");
 class UNKNOWN extends BTSensor{
+    static isSystem = true
+
     static identify(device){
         return null
     }
@@ -7,6 +9,13 @@ class UNKNOWN extends BTSensor{
         await super.init()
         if (!this.currentProperties.Name) 
             this.currentProperties.Name= `Unknown device from ${this.getManufacturer()}`
+        var md =this.addMetadatum("sensorClass",'',"Sensor Class")
+        md.isParam=true
+        md.enum=Array.from(this.constructor.classMap.keys())
+        //md.enumNames=this.constructor.classMap
+
     }
+
+
 }
 module.exports=UNKNOWN

package/sensor_classes/Victron/VictronSensor.js

@@ -53,7 +53,7 @@ function sleep(x) {
         await super.init()
         const md =this.addMetadatum('encryptionKey','', "Encryption Key")
         md.isParam = true
-        this.model_id=this.getManufacturerData(0x2e1).readUInt16LE(2)
+        this.model_id=this.getManufacturerData(0x2e1)?.readUInt16LE(2)??"Unknown"
     }
     alarmReason(alarmValue){
         return this.constructor.AlarmReason[alarmValue]

package/sensor_classes/VictronACCharger.js

@@ -67,7 +67,7 @@ class VictronACCharger extends VictronSensor{
         this.emit("batt3",  this.NaNif(br.read_unsigned_int(13),0x1FFF)/100)
         this.emit("curr3", this.NaNif(br.read_unsigned_int(11),0x7FF)/10)
         this.emit("temp", this.NaNif(br.read_unsigned_int(7),0x7F)+233.15)
-        this.emit("acCurr", this.NaNif(br.read_unsigned_int(9),0x1FF)/10)
+        this.emit("acCurr", this.NaNif(br.read_unsigned_int(9),0x1FF)/100)
     }
 }
 module.exports=VictronACCharger