bt-sensors-plugin-sk 1.1.0-beta.2.1.3.3 → 1.1.0-beta.2.1.4.1

package/BTSensor.js

@@ -152,7 +152,7 @@ class BTSensor extends EventEmitter {
      */
         class Metadatum{
         
-            constructor(tag, unit, description, read=()=>{return null}, gatt=null, type){
+            constructor(tag, unit, description, read, gatt=null, type){
                 this.tag = tag
                 this.unit = unit
                 this.description = description

package/index.js

@@ -90,15 +90,13 @@ module.exports =  function (app) {
 		  }, x);
 		});
 	  }
-	async function instantiateSensor(device,config){
+	  async function instantiateSensor(device,config){
 		try{
 		for (var [clsName, cls] of classMap) {
+			if (clsName.startsWith("_")) continue
 			const c = await cls.identify(device)
 			if (c) {
-				
-				if (c.name.startsWith("_")) continue
 				c.debug=app.debug
-				c.debug.bind(c)
 				const sensor = new c(device,config?.params, config?.gattParams)
 				sensor.debug=app.debug
 				await sensor.init()
@@ -356,7 +354,6 @@ module.exports =  function (app) {
 			})
 			.catch((error)=>
 				{
-					
 					const msg =`Sensor at ${deviceConfig.mac_address} unavailable. Reason: ${error}`
 					app.debug(msg)
 					app.debug(error)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bt-sensors-plugin-sk",
-  "version": "1.1.0-beta.2.1.3.3",
-  "description": "Bluetooth Sensors for Signalk -- support for Victron devices, RuuviTag, Xiaomi, ATC and Inkbird",
+  "version": "1.1.0-beta.2.1.4.1",
+  "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",
   "main": "index.js",
   "dependencies": {
     "dbus-next": "^0.10.2",

package/sensor_classes/ATC.js

@@ -8,16 +8,12 @@ class ATC extends BTSensor{
         }
     }
     static async identify(device){
-        try{
-            const regex = /^ATC_[A-Fa-f0-9]{6}$/
-            const name = await this.getDeviceProp(device,"Name")
-            if (name && name.match(regex)){
-                return this
-            }
-        } catch (e){
+        const regex = /^ATC_[A-Fa-f0-9]{6}$/
+        const name = await this.getDeviceProp(device,"Name")
+        if (name && name.match(regex))
+            return this
+        else
             return null
-        }
-        return null
     }
   
     async init() {

package/sensor_classes/BlackListedDevice.js

@@ -3,7 +3,8 @@ class BLACKLISTED extends BTSensor{
     static async identify(device){
         if (await this.getManufacturerID(device)===0x004C)   //apple devices use 
             return this                                     //randomised macs and clog up our list
-        return null
+        else
+            return null
     }
     async init(){
         await super.init()

package/sensor_classes/GoveeTH.js

@@ -0,0 +1,66 @@
+const BTSensor = require("../BTSensor");
+function decodeTempHumid(tempHumidBytes) {
+    // Convert the bytes to a 24-bit integer
+    const baseNum = (tempHumidBytes[0] << 16) + (tempHumidBytes[1] << 8) + tempHumidBytes[2];
+  
+    // Check if the temperature is negative
+    const isNegative = (baseNum & 0x800000) !== 0;
+  
+    // Extract the temperature and humidity values
+    const tempAsInt = baseNum & 0x7FFFFF;
+    const tempAsFloat = (tempAsInt / 1000) / 10.0;
+    const humid = (tempAsInt % 1000) / 10.0;
+  
+    // Apply the negative sign if necessary
+    if (isNegative) {
+      return {t:-tempAsFloat, h: humid};
+    } else {
+      return {t: tempAsFloat, h: humid};
+    }
+  }
+class GoveeTH extends BTSensor{
+
+    static async  identify(device){
+        const regex = /^GVH5[0-9]{3}_[a-f,A-F,0-9]{4}$/
+        const name = await this.getDeviceProp(device,"Name")
+        const uuids = await this.getDeviceProp(device,'UUIDs')
+
+        if (name && name.match(regex) && 
+            uuids && uuids.length > 0 && 
+            uuids[0] == '0000ec88-0000-1000-8000-00805f9b34fb')
+            return this
+        else
+            return null
+        
+    }
+
+    async init(){
+        await super.init()
+    }
+    initMetadata(){
+        this.addMetadatum('temp','K', 'temperature')
+        this.addMetadatum('battery','ratio', 'battery strength')
+        this.addMetadatum('humidity','ratio', 'humidity')
+    }
+
+    emitValuesFrom(buffer){
+        const th = decodeTempHumid(buffer.subarray(2,5))
+        this.emit("temp", parseFloat((273.15+th.t).toFixed(2))) ;
+        this.emit("humidity", th.h/100 )
+        this.emit('battery', buffer[5]/100)
+    }
+
+    getManufacturer(){
+        return "Govee"
+    }
+    async propertiesChanged(props){
+        super.propertiesChanged(props)    
+        if (props.ManufacturerData) {
+            const buffer = this.getManufacturerData(0x0001)
+            if (buffer) {
+               this.emitValuesFrom(buffer)
+            }      
+        }
+   }                         
+}
+module.exports=GoveeTH

package/sensor_classes/Inkbird.js

@@ -2,18 +2,15 @@ const BTSensor = require("../BTSensor");
 
 class Inkbird extends BTSensor{
 
-    static async identify(device){
-        try{
-            const uuids = await this.getDeviceProp(device,'UUIDs')
-            const name = await this.getDeviceProp(device,"Name")
-            if ((name == 'tps' || name=='sps') && (uuids.length > 0 && uuids[0] == '0000fff0-0000-1000-8000-00805f9b34fb')){
-                return this
-            }
-        } catch (e){
-            this.debug(e)
+    static async  identify(device){
+
+        const uuids = await this.getDeviceProp(device,'UUIDs')
+        const name = await this.getDeviceProp(device,"Name")
+        if ((name == 'tps' || name=='sps') && (uuids.length > 0 && uuids[0] == '0000fff0-0000-1000-8000-00805f9b34fb'))
+            return  this
+        else
             return null
-        }
-        return null
+        
     }
 
     async init(){

package/sensor_classes/MopekaTankSensor.js

@@ -243,19 +243,14 @@ class MopekaTankSensor extends BTSensor{
 
     static manufacturerID = 0x0059
     static async identify(device){
-        try{
-            if (await this.getManufacturerID(device)==this.manufacturerID ){
-                const uuids = await this.getDeviceProp(device, 'UUIDs')
-                if (uuids != null && uuids.length>0) {
-                    if (uuids.includes(this.serviceID)) 
-                        return this
-                }
-            }
-            
-        } catch (e){
-            this.debug.log(e)
-        }
-        return null
+        if (await this.getManufacturerID(device)==this.manufacturerID ){
+            const uuids = await this.getDeviceProp(device, 'UUIDs')
+            if (uuids && uuids.length>0 && uuids.includes(this.serviceID)) 
+                return this
+            else
+                return null
+        } else
+            return null
     }    
         
     async init(){
@@ -287,7 +282,7 @@ class MopekaTankSensor extends BTSensor{
             }).bind(this)
         )
         this.addMetadatum("battStrength","ratio","sensor battery strength", 
-            (buffer)=>{ return Math.max(0, Math.min(100, (((this.battVolt / 32.0) - 2.2) / 0.65))) }
+            (buffer)=>{ return Math.max(0, Math.min(1, (((this.battVolt) - 2.2) / 0.65))) }
         )
         this.addMetadatum("temp","K","temperature", 
             ((buffer)=>{ 

package/sensor_classes/RuuviTag.js

@@ -1,15 +1,11 @@
 const BTSensor = require("../BTSensor");
 class RuuviTag extends BTSensor{
     static manufacturerID = 0x0499
-    static async identify(device){
-        try{
-            if (await this.getManufacturerID(device)==this.manufacturerID)
-                return this
-        } catch (e){
-            console.log(e)
+    static  async identify(device){
+        if (await this.getManufacturerID(device)==this.manufacturerID)
+            return this
+        else
             return null
-        }
-        return null
     }    
         
     async init(){

package/sensor_classes/UltrasonicWindMeter.js

@@ -1,22 +1,18 @@
 const BTSensor = require("../BTSensor");
 class UltrasonicWindMeter extends BTSensor{
     static async identify(device){
-        try{
-            const uuids = await this.getDeviceProp(device,'UUIDs')
-            const name = await this.getDeviceProp(device,"Name")
-            if (name == 'ULTRASONIC'){
-                return this
-            }
-        } catch (e){
-            this.debug(e)
+        
+        const uuids = await this.getDeviceProp(device,'UUIDs')
+        const name = await this.getDeviceProp(device,"Name")
+        if (name == 'ULTRASONIC')
+            return this 
+        else
             return null
-        }
-        return null
     }
     hasGATT(){
         return true
     }
-    emitGatt(){
+    emitGATT(){
         this.battCharacteristic.readValue()
         .then((buffer)=>
             this.emitData("batt", buffer)
@@ -32,6 +28,17 @@ class UltrasonicWindMeter extends BTSensor{
         )
 
     }
+    async init(){
+        await super.init()
+        this.addMetadatum("batt","","Battery strength",
+            (buffer)=>{return buffer.readUInt8()})
+        this.addMetadatum("awa","","Apparent Wind Angle",
+            (buffer)=>{return buffer.readInt16LE()}
+        )
+        this.addMetadatum("aws","","Apparent Wind Speed",
+        (buffer)=>{return buffer.readInt16LE()}
+        )
+    }
 
     initGATTConnection(){ 
         return new Promise((resolve,reject )=>{ this.device.connect().then(async ()=>{ 

package/sensor_classes/Victron/VictronConstants.js

@@ -196,6 +196,7 @@ module.exports = {
     0xA2A2: "Phoenix Inverter 24V 3000VA 230V",
     0xA2A4: "Phoenix Inverter 48V 3000VA 230V",
     0xA31A: "Blue Smart AC Charger IP67",
+    0xA33B: "Blue Smart AC Charger IP65",
     0xA33C: "Blue Smart AC Charger IP65",
     0xA340: "Phoenix Smart IP43 Charger 12|50 (1+1)",
     0xA341: "Phoenix Smart IP43 Charger 12|50 (3)",

package/sensor_classes/Victron/VictronSensor.js

@@ -4,34 +4,57 @@ const int24 = require('int24')
 const util = require('util')
 const VC = require('./VictronConstants.js');
 const BLACKLISTED = require("../BlackListedDevice.js");
- 
+const { resolve } = require("node:path");
+const { setMaxIdleHTTPParsers } = require("node:http");
+function sleep(x) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(x);
+      }, x);
+    });
+  }
   class VictronSensor extends BTSensor{
 
     constructor(device,config,gattConfig){
         super(device,config,gattConfig)
         this.encryptionKey = config?.encryptionKey
     }
-   
+    
+    
     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
+            }
 
-        try{
-            const md = await this.getDeviceProp(device,'ManufacturerData')
-            if (!md) return null   
-            const data = md[0x2e1]
-            if (data && data.value[0]==0x2) { //VE.Smart is on
-                return BLACKLISTED
+            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)
             }
-            if (data && data.value[0]==0x10 && data.value[4]==mode)
+            device.helper.removeListeners()
+            if (md[0x2e1].value[4]==mode)
                 return this
-            else {
+            else
                 return null
-            }
-        } catch (e){
-            console.log(e)
-            return null
-        }
-        
+        } 
     }
+    
 
 
     async init(){
@@ -79,9 +102,8 @@ const BLACKLISTED = require("../BlackListedDevice.js");
         
         try{
             const md = this.getManufacturerData(0x2e1)
-            if (md.length && md[0]==0x10){
-                const buff = this.getManufacturerData(0x2e1)        
-                const decData=this.decrypt(buff)
+            if (md && md.length && md[0]==0x10){
+                const decData=this.decrypt(md)
                 this.emitValuesFrom(decData)
             }
         }

package/sensor_classes/VictronACCharger.js

@@ -20,7 +20,7 @@ Startbit Nr of bits Meaning Units Range NA value Remark
 
 const VictronSensor = require ("./Victron/VictronSensor.js") 
 const VC = require("./Victron/VictronConstants.js")
-const int24 = require('int24')
+const BitReader = require("./_BitReader")
 
 class VictronACCharger extends VictronSensor{
 
@@ -38,29 +38,36 @@ class VictronACCharger extends VictronSensor{
         this.addMetadatum('error','', 'error code', 
             (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
  
-        this.addMetadatum('batt1','V', 'battery 1 voltage',
-            (buff)=>{return this.NaNif((buff.readUInt16LE(2)&0x1FFF), 0x1FFF)/100})
+        this.addMetadatum('batt1','V', 'battery 1 voltage')
 
-        this.addMetadatum('curr1','A', 'battery 1 current',
-            (buff)=>{return this.NaNif(buff.readUInt16BE(3)&0x7FF,0x7FF)/10})
+        this.addMetadatum('curr1','A', 'battery 1 current')
 
-        this.addMetadatum('batt2','V', 'battery 2 voltage',
-            (buff)=>{return this.NaNif((buff.readUInt16LE(5)&0x1FFF), 0x1FFF)/100})
+        this.addMetadatum('batt2','V', 'battery 2 voltage')
 
-        this.addMetadatum('curr2','A', 'battery 2 current',
-            (buff)=>{return this.NaNif(buff.readUInt16BE(7)&0x7FF,0x7FF)/10})
+        this.addMetadatum('curr2','A', 'battery 2 current')
 
-        this.addMetadatum('batt3','V', 'battery 3 voltage',
-            (buff)=>{return this.NaNif((buff.readUInt16LE(8)&0x1FFF), 0x1FFF)/100})
+        this.addMetadatum('batt3','V', 'battery 3 voltage')
 
-        this.addMetadatum('curr3','A', 'battery 3 current',
-            (buff)=>{return this.NaNif(buff.readUInt16BE(9)&0x7FF,0x7FF)/10})
+        this.addMetadatum('curr3','A', 'battery 3 current')
     
-        this.addMetadatum('temp', 'K', 'battery temperature',
-            (buff)=>{return this.NaNif(buff.readUInt8(11)&0x7F,0x7F)+233.15}) //-40 plus K conversion
+        this.addMetadatum('temp', 'K', 'battery temperature')
 
-        this.addMetadatum('acCurr','A', 'AC current',
-            (buff)=>{return this.NaNif((buff.readUInt16BE(11)&0x1FF),0x1FF)/10})
+        this.addMetadatum('acCurr','A', 'AC current')
+    }
+    emitValuesFrom(buffer){
+        super.emitValuesFrom(buffer)
+        
+        const br = new BitReader(buffer.subarray(2))
+        this.emit("batt1",  this.NaNif(br.read_unsigned_int(13),0x1FFF)/100)
+        this.emit("curr1", this.NaNif(br.read_unsigned_int(11),0x7FF)/10)
+
+        this.emit("batt2",  this.NaNif(br.read_unsigned_int(13),0x1FFF)/100)
+        this.emit("curr2", this.NaNif(br.read_unsigned_int(11),0x7FF)/10)
+
+        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)
     }
 }
 module.exports=VictronACCharger

package/sensor_classes/VictronDCDCConverter.js

@@ -9,6 +9,9 @@ class VictronDCDCConverter extends VictronSensor{
    
     async init(){
         await super.init()
+        this.initMetadata()
+    }
+    initMetadata(){
         this.addMetadatum('deviceState','', 'device state', 
                 (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
         this.addMetadatum('chargerError','', 'charger error',

package/sensor_classes/VictronDCEnergyMeter.js

@@ -1,6 +1,8 @@
+
 const VictronSensor = require("./Victron/VictronSensor");
 const VC=require("./Victron/VictronConstants.js")
-
+const int24 = require("int24");
+const _BitReader = require("./_BitReader.js");
 class VictronDCEnergyMeter extends VictronSensor{
     
     static async identify(device){
@@ -14,9 +16,11 @@ class VictronDCEnergyMeter extends VictronSensor{
             (buff)=>{return buff.readInt16LE(2)/100})
         this.addMetadatum('alarm','', 'alarm', 
             (buff)=>{return buff.readUInt16LE(4)})
-        this.addMetadatum('current','A', 'current')    
-        const modeCurrent =  this.getAuxModeAndCurrent()
-        this.auxMode= modeCurrent.auxMode
+        if (this.encryptionKey){
+            const decData = this.decrypt(this.getManufacturerData(0x02e1))
+            if (decData)
+                this.auxMode=decData.readInt8(8)&0x3   
+        }
         switch(this.auxMode){
             case VC.AuxMode.STARTER_VOLTAGE:
                 this.addMetadatum('starterVoltage','V',  'starter battery voltage', 
@@ -36,6 +40,8 @@ class VictronDCEnergyMeter extends VictronSensor{
             default:
                 break
         }
+        this.addMetadatum('current','A', 'current')        
+ 
     }
     
     emitValuesFrom(decData){
@@ -56,8 +62,10 @@ class VictronDCEnergyMeter extends VictronSensor{
                 break;
             default:
                 break
-            }      
-        this.emit("current", this.getAuxModeAndCurrent(8,decData).current)
+            } 
+
+        this.emit("current", 
+            this.NaNif( new _BitReader(decData.subarray(8,11)).read_signed_int(22),0x3FFFFF)/1000)
   
     }
     

package/sensor_classes/VictronGXDevice.js

@@ -28,16 +28,19 @@ TBD
 
     async init() {
         await super.init()
+        this.initMetadata()
+    }
+    initMetadata(){
         this.addMetadatum('voltage','V', 'channel #1 voltage', 
             (buff)=>{return this.NaNif(buff.readInt16LE(0),0xFFFF)/100})
         this.addMetadatum('pvPower','W','DC input power in watts', 
-            (buff)=>{return this.NaNif(int24.readInt24BE(buff,2)>>4,0xFFFFF)})
+            (buff)=>{return this.NaNif(int24.readInt24LE(buff,2)>>4,0xFFFFF)})
         this.addMetadatum('soc','ratio', 'state of charge', 
-            (buff)=>{ return ((buff.readUInt16BE(4)&0xfff)>>5)/100})
+            (buff)=>{ return ((buff.readUInt16LE(4)&0xfff)>>5)/100})
         this.addMetadatum('batteryPower','W', 'battery power', 
-            (buff)=>{return (this.NaNif(int24.readInt24BE(buff,5)&0x1ffff),0x0FFFFF )})    
+            (buff)=>{return (this.NaNif(int24.readInt24LE(buff,5)&0x1ffff),0x0FFFFF )})    
         this.addMetadatum('DCPower','W', 'DCpower', 
-            (buff)=>{return this.NaNif(int24.readInt24BE(buff,8)>>3,0x0FFFFF )})    
+            (buff)=>{return this.NaNif(int24.readInt24LE(buff,8)>>3,0x0FFFFF )})    
         }
 }
 module.exports=VictronGXDevice

package/sensor_classes/VictronInverter.js

@@ -1,6 +1,6 @@
 const VictronSensor = require("./Victron/VictronSensor");
 const VC=require("./Victron/VictronConstants.js")
-
+const BitReader = require('./_BitReader')
 
 class VictronInverter extends VictronSensor{
     static async identify(device){
@@ -9,6 +9,9 @@ class VictronInverter extends VictronSensor{
 
     async init() {
         await super.init()
+        this.initMetadata()
+    }
+    initMetadata(){
         this.addMetadatum('deviceState','', 'inverter device state', 
             (buff)=>{return VC.OperationMode.get(buff.readIntU8(0))})
         const md = this.addMetadatum('alarmReason','', 'reason for alarm',
@@ -19,17 +22,19 @@ class VictronInverter extends VictronSensor{
             (buff)=>{return this.NaNif(buff.readInt16LE(3),0x7FFF)/100})
         this.addMetadatum('acPower','W', 'AC power (in watts: Apparent Power * Power Factor)', 
             (buff)=>{return this.NaNif( buff.readUInt16LE(5), 0xFFFF )*this.powerFactor})
-        this.addMetadatum('acVoltage','V','AC Voltage', 
-            (buff)=>{return this.NaNif((buff.readUInt16BE(5)>>1),0x7FFF)/10})
-        this.addMetadatum('acCurrent','A', 'AC Current',
-            (buff)=>{return this.NaNif(((buff.readUInt32BE(5)&0x7ffff)>>6),0x7FF)/10}
-        )
+        this.addMetadatum('acVoltage','V','AC Voltage')
+        this.addMetadatum('acCurrent','A', 'AC Current')
                 
     }
     powerFactor = .8 //parameterize anon
 
     emitValuesFrom(decData){
         super.emitValuesFrom(decData)
+        const br = new BitReader(decData.subarray(5))
+        this.emit('acVoltage',
+            this.NaNif(br.read_unsigned_int(15),0x7FFF)/100)
+        this.addMetadatum('acCurrent',
+            this.NaNif(br.read_unsigned_int(11),0x7FF)/10)
         const alarm = this.getMetadatum("alarmReason").read(decData)
         if (alarm>0){
             this.emit(

package/sensor_classes/VictronLynxSmartBMS.js

@@ -15,8 +15,7 @@ Start Bit	Nr of Bits	Meaning	Units	Range	NA Value	Remark
 
 const VictronSensor = require ("./Victron/VictronSensor.js") 
 const VC = require("./Victron/VictronConstants.js")
-const int24 = require('int24')
-
+const BitReader = require("./_BitReader")
 class VictronLynxSmartBMS extends VictronSensor{
 
     static async identify(device){
@@ -25,6 +24,9 @@ class VictronLynxSmartBMS extends VictronSensor{
 
     async init() {
         await super.init()
+        this.initMetadata()
+    }
+    initMetadata(){
         this.addMetadatum('error','', 'error code', 
             (buff)=>{return buff.readUInt8(0)})
  
@@ -35,15 +37,24 @@ class VictronLynxSmartBMS extends VictronSensor{
         this.addMetadatum('current','A','channel 1 current', 
             (buff)=>{return this.NaNif(buff.readInt16LE(5),0x7FFF)/10})
         this.addMetadatum('ioStatus','','IO Status', //TODO
-            (buff)=>{return buff.readInt16LE(7)})
-        this.addMetadatum('warningsAndAlarms','','warnings and alarms', //TODO
-            (buff)=>{return (int24.readUInt24BE(buff,9)>>6)})
-        this.addMetadatum('soc','','state of charge',
-            (buff)=>{return this.NaNif(((buff.readUInt16BE(11)&0x3fff)>>4),0x3FF)/1000})
-        this.addMetadatum('consumedAh','Ah','amp-hours consumed',
-            (buff)=>{return this.NaNif((int24.readUInt24BE(13)>>4),0xFFFFF)/10} )
-        this.addMetadatum('temp', 'K', 'battery temperature',
-            (buff)=>{this.NaNif( buff.readUInt8(15)>>1,0x7f) +233.15})
+            (buff)=>{return buff.readUInt16LE(7)})
+        this.addMetadatum('warningsAndAlarms','','warnings and alarms')
+        this.addMetadatum('soc','','state of charge')
+        this.addMetadatum('consumedAh','Ah','amp-hours consumed')
+        this.addMetadatum('temp', 'K', 'battery temperature')
+    }
+    emitValuesFrom(buffer){
+        super.emitValuesFrom(buffer)
+        const br = new BitReader(buffer.subarray(9))
+
+        this.emit('warningsAndAlarms',br.read_unsigned_int(18))
+        this.emit('soc',
+            this.NaNif((br.read_unsigned_int(10),0x3FF)/1000))
+        this.emit('consumedAh',
+            this.NaNif(br.read_unsigned_int(20),0xFFFFF)/10 )
+        this.emit('temp', 
+            this.NaNif( br.read_unsigned_int(7),0x7f) +233.15)
+ 
     }
 }
 module.exports=VictronLynxSmartBMS

package/sensor_classes/VictronSmartBatteryProtect.js

@@ -25,6 +25,9 @@ class VictronSmartBatteryProtect extends VictronSensor{
 
     async init() {
         await super.init()
+        this.initMetadata()
+    }
+    initMetadata(){
         this.addMetadatum('deviceState','', 'device state', 
                         (buff)=>{return VC.OperationMode.get(buff.readUInt8(1))})
         this.addMetadatum('outputStatus','', 'output status', //TODO

package/sensor_classes/VictronSmartLithium.js

@@ -16,9 +16,13 @@ Start Bit	Nr of Bits	Meaning	Units	Range	NA Value	Remark
 152	7	Battery temperature	1°C	-40..86 °C	0x7F	VE_REG_BAT_TEMPERATURE Temperature = Record value - 40
 159	1	Unused				
 VE_REG_BATTERY_CELL_VOLTAGE 0x00 ( 0) when cell voltage < 2.61V 0x01 ( 1) when cell voltage == 2.61V 0x7D (125) when cell voltage == 3.85V 0x7E (126) when cell voltage > 3.85 0x7F (127) when cell voltage is not available / unknown
-*/const VictronSensor = require ("./Victron/VictronSensor.js") 
-const VC = require("./Victron/VictronConstants.js")
+*/const VictronSensor = require ("./Victron/VictronSensor") 
+const VC = require("./Victron/VictronConstants")
+const BitReader = require("./_BitReader")
 
+function _toCellVoltage(val){    
+    return val==0x7F?NaN:2.6+(val/100)
+}
 class VictronSmartLithium extends VictronSensor{
 
     static async identify(device){
@@ -30,36 +34,32 @@ class VictronSmartLithium extends VictronSensor{
         this.initMetadata()
     }
     initMetadata(){
-        function _toCellVoltage(val){    
-            return val==0x7F?NaN:2.6+(val/100)
-        }
+
         this.addMetadatum('bmsFlags','', 'BMS Flags', 
-                        (buff)=>{return buff.readUInt32BE(0)})
+                        (buff)=>{return buff.readUInt32LE(0)})
 
         this.addMetadatum('smartLithiumErrors','', 'Smart Lithium Errors Flags',
-            (buff)=>{return buff.readUInt16BE(4)})
-        this.addMetadatum('cell1Voltage','V', 'cell #1 voltage', 
-            (buff)=>{return _toCellVoltage((buff.readUInt8(6))>>1)})
-        this.addMetadatum('cell2Voltage','V', 'cell #2 voltage', 
-            (buff)=>{return _toCellVoltage(((buff.readUInt16BE(6))&0x01Fe)>>2)})
-        this.addMetadatum('cell3Voltage','V', 'cell #3 voltage', 
-            (buff)=>{return _toCellVoltage(((buff.readUInt16BE(7))&0x03Fe)>>3)})
-        this.addMetadatum('cell4Voltage','V', 'cell #4 voltage', 
-            (buff)=>{return _toCellVoltage(((buff.readUInt16BE(8))&0x07fe)>>4)})
-        this.addMetadatum('cell5Voltage','V', 'cell #5 voltage', 
-            (buff)=>{return _toCellVoltage(((buff.readUInt16BE(9))&0x0ffe)>>5)})
-        this.addMetadatum('cell6Voltage','V', 'cell #6 voltage', 
-            (buff)=>{return _toCellVoltage(((buff.readUInt16BE(10))&0x1ffe)>>6)})
-        this.addMetadatum('cell7Voltage','V', 'cell #7 voltage', 
-            (buff)=>{return _toCellVoltage(((buff.readUInt16BE(11))&0x3ffe)>>7)})
-        this.addMetadatum('cell8Voltage','V', 'cell #8 voltage', 
-            (buff)=>{return _toCellVoltage((buff.readUInt8(12))&0x7e)})
+            (buff)=>{return buff.readUInt16LE(4)})
+        this.addMetadatum('cell1Voltage','V', 'cell #1 voltage')
+        this.addMetadatum('cell2Voltage','V', 'cell #2 voltage')
+        this.addMetadatum('cell3Voltage','V', 'cell #3 voltage')
+        this.addMetadatum('cell4Voltage','V', 'cell #4 voltage')
+        this.addMetadatum('cell5Voltage','V', 'cell #5 voltage')
+        this.addMetadatum('cell6Voltage','V', 'cell #6 voltage')
+        this.addMetadatum('cell7Voltage','V', 'cell #7 voltage')
+        this.addMetadatum('cell8Voltage','V', 'cell #8 voltage')
         this.addMetadatum('batteryVoltage','V', 'battery voltage', 
             (buff)=>{return this.NaNif((buff.readUInt16LE(13)&0xFFF),0xFFF)/100})
         this.addMetadatum('balancerStatus','', 'balancer status', //TODO
-            (buff)=>{return this.NaNif((buff.readUInt8(14)&0xf),0xF)})
+            (buff)=>{return this.NaNif((buff.readUInt8(14)>>4),0xF)})
         this.addMetadatum('batteryTemp','K', 'battery temperature', 
             (buff)=>{return this.NaNif((buff.readUInt8(15)&0x7F),0x7F)+233.15})          
     }
+    emitValuesFrom(buffer){
+        super.emitValuesFrom(buffer)
+        const br = new BitReader(buffer.subarray(6,13))
+        for (let i = 1; i<8; i++)
+            this.emit(`cell${i+1}Voltage`,_toCellVoltage(br.read_unsigned_int(7)))
+    }
 }
 module.exports=VictronSmartLithium

package/sensor_classes/VictronSolarCharger.js

@@ -24,7 +24,7 @@ class VictronSolarCharger extends VictronSensor{
     this.addMetadatum('solarPower','W', 'solar power', 
         (buff)=>{return this.NaNif(buff.readUInt16LE(8),0xFFFF)})    
     this.addMetadatum('externalDeviceLoad','A', 'external device load', 
-        (buff)=>{return this.NaNif(buff.readUInt16BE(10)>>7,0x1FF)})    
+        (buff)=>{return this.NaNif(buff.readUInt16LE(10)&0x1FF,0x1FF)/10})    
     }
 }
 module.exports=VictronSolarCharger 

package/sensor_classes/VictronVEBus.js

@@ -1,6 +1,6 @@
 const VictronSensor = require ("./Victron/VictronSensor.js") 
 const VC = require("./Victron/VictronConstants.js")
-const int24 = require('int24')
+const BitReader = require("./_BitReader")
 AC_IN_STATE=["AC in 1","AC in 2","NOT CONNECTED", "NA"]
 ALARM_STATE=["None","warning", "alarm","NA"]
 class VictronVEBus extends VictronSensor{
@@ -11,7 +11,9 @@ class VictronVEBus extends VictronSensor{
 
     async init() {
         await super.init()
-
+        this.initMetadata()
+    }
+    initMetadata(){
         this.addMetadatum('chargeState','', 'charge state', 
             (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
             
@@ -21,27 +23,44 @@ class VictronVEBus extends VictronSensor{
         this.addMetadatum('current','A','charger battery current', 
             (buff)=>{return this.NaNif(buff.readInt16LE(2),0x7FFF)/10})
         
-        this.addMetadatum('voltage','V', 'charger battery voltage',
-            (buff)=>{return this.NaNif(buff.readUInt16LE(4) & 0x3FFF,0x3FFF)/100})
+        this.addMetadatum('voltage','V', 'charger battery voltage')
          
-        this.addMetadatum('acInState','', 'AC in state', 
-            (buff)=>{return AC_IN_STATE[readUInt8(5)>>6]})
+        this.addMetadatum('acInState','', 'AC in state')
         
-        this.addMetadatum('acInPower','W','AC power IN in watts',  
-            (buff)=>{return this.NaNif(int24.readInt24LE(buff,6)>>5,0x3FFFF)*(raw & 0x40000)?-1:1})
+        this.addMetadatum('acInPower','W','AC power IN in watts')
         
-        this.addMetadatum('acOutPower','W','AC power OUT in watts',  
-            (buff)=>{return this.NaNif((int24.readInt24LE(buff,8) & 0x1FFFF) >> 2,0x3FFFF) * (raw & 0b1)?-1:1})
+        this.addMetadatum('acOutPower','W','AC power OUT in watts')
         
-        this.addMetadatum('alarm','','alarm state 0=no alarm, 1=warning, 2=alarm',  
-            (buff)=>{return ALARM_STATE[buff.readUInt8(10)&0x3] })
+        this.addMetadatum('alarm','','alarm state 0=no alarm, 1=warning, 2=alarm')
         
-        this.addMetadatum('batteryTemperature','K', 'battery temperature', 
-            (buff)=>{return this.NaNif((buff.readInt8(10)&0x1FF)>>1,0x7F) +233.15})    
+        this.addMetadatum('batteryTemperature','K', 'battery temperature')    
 
-        this.addMetadatum('soc', 'ratio', 'state of charge',
-            (buff)=>{return this.NaNif((buff.readInt16BE(10)&0x1FF)>>2,0x7F)/100})    
+        this.addMetadatum('soc', 'ratio', 'state of charge')    
             
     }
+    emitValuesFrom(buffer){
+        super.emitValuesFrom(buffer)
+        const br = new BitReader(buffer.subarray(4))
+        this.emit('voltage',
+            this.NaNif(br.read_unsigned_int(14),0x3FFF)/100)
+         
+        this.emit('acInState',
+            AC_IN_STATE[br.read_unsigned_int(2)])
+        
+        this.emit('acInPower',
+            this.NaNif(br.read_signed_int(19),0x3FFFF))
+        
+        this.emit('acOutPower',
+            this.NaNif(br.read_signed_int(19),0x3FFFF))
+        
+        this.emit('alarm', ALARM_STATE[br.read_unsigned_int(2)])
+        
+        this.emit('batteryTemperature',
+            this.NaNif((br.read_unsigned_int(7),0x7F))+233.15)  
+
+        this.emit('soc', 
+            this.NaNif((br.read_unsigned_int(7),0x7F))/100)
+ 
+    }
 }
 module.exports=VictronVEBus

package/sensor_classes/XiaomiMiBeacon.js

@@ -80,16 +80,16 @@ class XiaomiMiBeacon extends BTSensor{
     static SERVICE_MIBEACON = "0000fe95-0000-1000-8000-00805f9b34fb"
 
     static async identify(device){
-        try{
-            const sd = await this.getDeviceProp(device, 'ServiceData')
-            if (sd == null || sd.length==0) return null
-            const keys = Object.keys(sd)
-            if (keys[0]==this.SERVICE_MIBEACON) return this
-        } catch (e){
-            console.log(e)
+        var sd = await this.getDeviceProp(device, 'ServiceData')
+        if (sd == null || sd.length==0) 
             return null
+        else{
+            const keys = Object.keys(sd)
+            if (keys[0]==this.SERVICE_MIBEACON) 
+                return this
+            else
+                return null
         }
-        return null
     }
 
     GATTwarning = "WARNING: Xiaomi GATT connections are known to be unreliable on Debian distributions with Bluez 5.55 and up (earlier BlueZ versions are untested). Using GATT on the Xiaomi may put the system Bluetooth stack into an inconsistent state disrupting and disabling other plugin Bluetooth connections. If by some chance you're successful using GATT with the Xiaomi, let the plugin developer know your configuration. Refer to the plugin documentation for getting the Xiamoi bindKey for non-GATT connections and more information on Xiaomi GATT issues."

package/sensor_classes/_BitReader.js

@@ -0,0 +1,28 @@
+/*
+Ported from Python original by Keshav Varma https://github.com/keshavdv
+*/
+class _BitReader{
+    constructor( data){
+        this._data = data
+        this._index = 0
+    }
+    read_bit(){
+        const bit = (this._data[this._index >> 3] >> (this._index & 7)) & 1
+        this._index++
+        return bit
+    }
+
+    read_unsigned_int(num_bits){
+        var value =''
+        for (let i = 0; i < num_bits; i++)
+            value = this.read_bit().toString()+value
+        return parseInt(value,2)
+    }
+    read_signed_int(num_bits){ 
+        const value = this.read_unsigned_int(num_bits)
+        return value & (1 << (num_bits - 1))?value - (1 << num_bits):value
+    }
+    
+}
+
+module.exports=_BitReader