bt-sensors-plugin-sk 1.0.3 → 1.1.0-beta.1

package/sensor_classes/Victron/VictronSensor.js

@@ -0,0 +1,106 @@
+const BTSensor = require("../../BTSensor.js");
+const crypto = require('node:crypto');
+const int24 = require('int24')
+const util = require('util')
+const VC = require('./VictronConstants.js')
+ 
+  class VictronSensor extends BTSensor{
+
+    constructor(device,config,gattConfig){
+        super(device,config,gattConfig)
+        this.encryptionKey = config?.encryptionKey
+    }
+   
+    static {
+        this.metadata = new Map(super.getMetadata())
+        const md = this.addMetadatum('encryptionKey','', "Encryption Key")
+        md.isParam = true
+    }
+
+    static async identifyMode(device, mode){
+
+        try{
+            const md = await this.getDeviceProp(device,'ManufacturerData')
+            if (!md) return null   
+            const data = md[0x2e1]
+            if (data && data.value[0]==0x10 && data.value[4]==mode)
+                return this
+            else
+                return null
+        } catch (e){
+            console.log(e)
+            return null
+        }
+        
+    }
+
+    getAuxModeAndCurrent(offset, decData=null){
+        if (decData==null){
+            decData=this.getManufacturerData(0x2e1)
+            if (this.encryptionKey)
+                decData=this.decrypt(decData)
+            else 
+                return {current:NaN, auxMode:NaN}
+        } 
+        const auxModeAndCurrent = int24.readInt24LE(decData,offset)
+        return {
+            current : (this.NaNif(auxModeAndCurrent >> 2,0x3FFFFF))/1000,
+            auxMode : auxModeAndCurrent & 0b11
+        }
+    }
+
+    async init(){
+        await super.init()
+        this.model_id=this.getManufacturerData(0x2e1).readUInt16LE(2)
+    }
+    alarmReason(alarmValue){
+        return this.constructor.AlarmReason[alarmValue]
+    }
+    getModelName(){
+        return VC.MODEL_ID_MAP[this.model_id]
+    }
+
+    decrypt(data){
+        if (!this.encryptionKey)
+            throw Error("Unable to decrypt: no encryption key set")
+
+        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)
+
+        return Buffer.from(decData)
+        
+    }
+    getName(){
+        return `Victron ${this.getModelName()}`
+    }
+    propertiesChanged(props){
+        super.propertiesChanged(props)
+        if (this.usingGATT()) return
+        try{
+            const buff = this.getManufacturerData(0x2e1)             
+            const decData=this.decrypt(buff)
+            this.emitValuesFrom(decData)
+        }
+        catch (error) {
+            throw new Error(`Unable to read data from ${ this.getDisplayName()}: ${error}` )
+        }
+    }
+
+    initGATT(){
+        throw new Error( "GATT Connection unimplemented for "+this.getDisplayName())
+    }
+
+   
+
+}
+module.exports=VictronSensor

package/sensor_classes/VictronACCharger.js

@@ -0,0 +1,64 @@
+/*AC Charger
+Record layout is still to be determined and might change.
+Last update: 2022/12/14 13:25 rend:ble:extra_manufacturer_data https://wiki.victronenergy.com/rend/ble/extra_manufacturer_data
+https://wiki.victronenergy.com/ Printed on 2022/12/14 13:27
+Startbit Nr of bits Meaning Units Range NA value Remark
+32 8 Device state 0 .. 0xFE 0xFF VE_REG_DEVICE_STATE
+40 8 Charger Error 0 .. 0xFE 0xFF VE_REG_CHR_ERROR_CODE
+48 13 Battery voltage 1 0.01 V 0 .. 81.90V 0x1FFF VE_REG_DC_CHANNEL1_VOLTAGE
+61 11 Battery current 1 0.1A 0 .. 204.6A 0x7FF VE_REG_DC_CHANNEL1_CURRENT
+72 13 Battery voltage 2 0.01 V 0 .. 81.90V 0x1FFF VE_REG_DC_CHANNEL2_VOLTAGE
+85 11 Battery current 2 0.1A 0 .. 204.6A 0x7FF VE_REG_DC_CHANNEL2_CURRENT
+96 13 Battery voltage 3 0.01 V 0 .. 81.90V 0x1FFF VE_REG_DC_CHANNEL3_VOLTAGE
+109 11 Battery current 3 0.1A 0 .. 204.6A 0x7FF VE_REG_DC_CHANNEL3_CURRENT
+120 7 Temperature °C -40 .. 86°C 0x7F VE_REG_BAT_TEMPERATURE Temperature = Record value - 40
+127 9 AC current 0.1A 0 .. 51.0 A 0x1FF VE_REG_AC_ACTIVE_INPUT_L1_CURRENT
+136 24 Unused
+*/
+
+
+
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+const int24 = require('int24')
+
+class VictronACCharger extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x0A)
+    }   
+
+    static {
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('state','', 'device state', 
+            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+        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.readUInt16BE(2)>>3), 0x1FFF)/100})
+
+        this.addMetadatum('curr1','A', 'battery 1 current',
+            (buff)=>{return this.NaNif(buff.readUInt16BE(3)&0x7FF,0x7FF)/10})
+
+        this.addMetadatum('batt2','V', 'battery 2 voltage',
+            (buff)=>{return this.NaNif((buff.readUInt16BE(5)>>3), 0x1FFF)/100})
+
+        this.addMetadatum('curr2','A', 'battery 2 current',
+            (buff)=>{return this.NaNif(buff.readUInt16BE(7)&0x7FF,0x7FF)/10})
+
+            this.addMetadatum('batt3','V', 'battery 3 voltage',
+                (buff)=>{return this.NaNif((buff.readUInt16BE(8)>>3), 0x1FFF)/100})
+
+        this.addMetadatum('curr3','A', 'battery 3 current',
+            (buff)=>{return this.NaNif(buff.readUInt16BE(9)&0x7FF,0x7FF)/10})
+    
+        this.addMetadatum('temp', 'K', 'battery temperature',
+            (buff)=>{return this.NaNif(buff.readUInt8(11)>>1,0x7F)+233.15}) //-40 plus K conversion
+
+        this.addMetadatum('acCurr','A', 'AC current',
+            (buff)=>{return this.NaNif((buff.readInt16BE(11))&0x1FFF,0x1FFF)})
+    }
+}
+module.exports=VictronACCharger

package/sensor_classes/VictronBatteryMonitor.js

@@ -0,0 +1,160 @@
+const VictronSensor = require("./Victron/VictronSensor.js");
+const VC=require("./Victron/VictronConstants.js")
+class VictronBatteryMonitor extends VictronSensor{
+    static {
+        this.metadata = new Map(super.getMetadata())
+        this.addMetadatum('current', 'A', 'house battery amperage', 
+                (buff,offset=0)=>{return buff.readInt32LE(offset)/1000},
+                '6597ed8c-4bda-4c1e-af4b-551c4cf74769')
+        this.addMetadatum('power','W', 'house battery wattage',
+                (buff,offset=0)=>{return buff.readInt16LE(offset)},
+                '6597ed8e-4bda-4c1e-af4b-551c4cf74769')
+        this.addMetadatum('voltage','V',  'house battery voltage', 
+                (buff,offset=0)=>{return this.NaNif(buff.readInt16LE(offset), 0x7FFF)/100},
+                '6597ed8d-4bda-4c1e-af4b-551c4cf74769',)
+        const alarmMD = this.addMetadatum('alarm','',  'alarm', 
+                (buff,offset=0)=>{return buff.readInt16LE(offset)})
+                alarmMD.notify=true
+
+        this.addMetadatum( 'consumed','C', 'amp-hours consumed', 
+                (buff,offset=0)=>{return buff.readInt32LE(offset)/10},
+                '6597eeff-4bda-4c1e-af4b-551c4cf74769',)
+
+        this.addMetadatum( 'soc','ratio', 'state of charge', 
+                (buff,offset=0)=>{return buff.readUInt16LE(offset)/10000},
+                '65970fff-4bda-4c1e-af4b-551c4cf74769')    
+
+        this.addMetadatum( 'ttg','s','time to go', 
+                (buff,offset=0)=>{return this.NaNif(buff.readUInt16LE(offset),0xFFFF)*60},
+                '65970ffe-4bda-4c1e-af4b-551c4cf74769')    
+    }
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x02)
+    }
+
+    characteristics=[]
+    async init(){
+        await super.init()
+        const modecurrent = this.getAuxModeAndCurrent()
+        this.auxMode= modecurrent.auxMode
+        switch(this.auxMode){
+            case VC.AuxMode.STARTER_VOLTAGE:
+                this.addMetadatum('starterVoltage','V', 'starter battery voltage', 
+                    (buff,offset=0)=>{return buff.readInt16LE(offset)/100},
+                    '6597ed7d-4bda-4c1e-af4b-551c4cf74769')
+                break;
+            case VC.AuxMode.MIDPOINT_VOLTAGE:
+                this.addMetadatum('midpointVoltage','V', 'midpoint battery voltage', 
+                    (buff,offset=0)=>{return buff.readInt16LE(offset)/100},
+                    '6597ed7d-4bda-4c1e-af4b-551c4cf74769')
+                break;
+
+            case VC.AuxMode.TEMPERATURE:
+                this.addMetadatum('temperature','K', 'House battery temperature', 
+                    (buff,offset=0)=>{return buff.readInt16LE(offset)/100},
+                    '6597ed7d-4bda-4c1e-af4b-551c4cf74769')
+                break;
+            default:
+                break
+        }
+    }
+
+    emitValuesFrom(decData){
+        this.emitData("ttg",decData,0)
+        this.emitData("voltage",decData,2);
+        const alarm = this.getMetadatum("alarm").read(decData,4)
+        if (alarm>0){
+            this.emit(
+                `ALARM #${alarm} from ${this.getDisplayName()})`, 
+                { message: AlarmReason.get(alarm), state: 'alert'})
+        }
+        
+        this.emit("current", (this.getAuxModeAndCurrent(8,decData)).current)
+        switch(this.auxMode){
+        case VC.AuxMode.STARTER_VOLTAGE:
+            this.emitData("starterVoltage",decData,6);
+            break;
+        case VC.AuxMode.MIDPOINT_VOLTAGE:
+            this.emitData("midpointVoltage",decData,6);
+            break;
+        case VC.AuxMode.TEMPERATURE:
+            this.emitData("temperature",decData,6);
+            break;
+        default:
+            break
+        }      
+        this.emit("consumed",decData.readInt16LE(11) / 10 ); //TODO this ain't right
+        var soc = decData.readUInt16LE(13)
+        this.emit("soc", ((soc & 0x3FFF) >> 4) / 1000)
+    }
+    
+    initGATT() {
+        return new Promise((resolve,reject )=>{
+            if (!this.valueIfVariant(this.currentProperties.Paired))
+                reject(`${this.getName()} must be paired with the Signalk server to use GATT protocol`)
+            this.device.connect().then(async ()=>{
+                if (!this.gattServer) {
+                    this.gattServer = await this.device.gatt()
+                    this.gattService= await this.gattServer.getPrimaryService("65970000-4bda-4c1e-af4b-551c4cf74769")
+                    const keepAlive = await this.gattService.getCharacteristic('6597ffff-4bda-4c1e-af4b-551c4cf74769')
+                    await keepAlive.writeValue(Buffer.from([0xFF,0xFF]), { offset: 0, type: 'request' })
+                }
+                resolve(this)
+            }).catch((e)=>reject(e.message))
+        })
+    }
+    emitGATT(){
+        this.getPathMetadata().forEach( (datum, tag)=> {
+            if (datum.gatt) {
+            this.gattService.getCharacteristic(datum.gatt).then((gattCharacteristic)=>{
+                gattCharacteristic.readValue().then((buffer)=>{
+                    this.emitData(tag, buffer)
+                })
+            }).catch((e)=>{
+                throw new Error(e)
+            })}
+        })
+    }
+    initGATTNotifications(){
+        return new Promise((resolve,reject )=>{
+
+        this.getPathMetadata().forEach((datum, tag)=> {
+            if (datum.gatt) {
+            this.gattService.getCharacteristic(datum.gatt).then(async (gattCharacteristic)=>{
+                const buffer = await gattCharacteristic.readValue()
+                this.emitData(tag, buffer)
+                
+                gattCharacteristic.startNotifications().then(()=>{
+                    gattCharacteristic.on('valuechanged', buffer => {
+                        this.emitData(tag, buffer)
+                    })
+                    this.characteristics.push(gattCharacteristic)
+                })
+            })
+        }})
+        resolve(this)})
+    }
+    propertiesChanged(props){
+        super.propertiesChanged(props)
+    }
+    canUseGATT(){
+        return true
+    }
+    
+    getGATTDescription(){
+        return "To use the GATT connection the SignalK server computer and the Smart Shunt must first be paired."
+    }
+
+    async disconnect(){
+        super.disconnect()
+        for (var c of this.characteristics){
+            await c.stopNotifications()
+        }
+        if (await this.device.isConnected()){
+            console.log(`Disconnecting from ${ this.getMacAddress()}`)
+            await this.device.disconnect()
+        }
+    }
+}
+module.exports=VictronBatteryMonitor

package/sensor_classes/VictronDCDCConverter.js

@@ -0,0 +1,26 @@
+const VictronSensor = require("./Victron/VictronSensor");
+const VC=require("./Victron/VictronConstants.js")
+
+class VictronDCDCConverter extends VictronSensor{
+    
+    static async identify(device){
+        return await this.identifyMode(device,0x04)
+    }
+   
+    static {
+        this.metadata= new Map(super.getMetadata())
+        this.addMetadatum('deviceState','', 'device state', 
+                (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+        this.addMetadatum('chargerError','', 'charger error',
+                (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
+        this.addMetadatum('inputVoltage','V', 'input voltage', 
+                (buff)=>{return this.NaNif(buff.readUInt16LE(2),0xFFFF)/100})
+        this.addMetadatum('outputVoltage','V', 'output voltage', 
+                (buff)=>{return this.NaNif(buff.readInt16LE(4),0x7FFF)/100 })
+        this.addMetadatum('offReason','', 'reason unit is off',
+                (buff)=>{return VC.OffReasons.get(buff.readUInt32LE(6))})
+                
+    }    
+
+}
+module.exports=VictronDCDCConverter 

package/sensor_classes/VictronDCEnergyMeter.js

@@ -0,0 +1,68 @@
+const VictronSensor = require("./Victron/VictronSensor");
+const VC=require("./Victron/VictronConstants.js")
+
+class VictronDCEnergyMeter extends VictronSensor{
+    
+    static async identify(device){
+        return await this.identifyMode(device, 0x0D)
+    }
+    async init(){
+        await super.init()
+        const modeCurrent =  this.getAuxModeAndCurrent()
+        this.auxMode= modeCurrent.auxMode
+        switch(this.auxMode){
+            case VC.AuxMode.STARTER_VOLTAGE:
+                this.addMetadatum('starterVoltage','V',  'starter battery voltage', 
+                        (buff,offset=0)=>{return buff.readInt16LE(offset)/100})
+                        break;
+
+            case VC.AuxMode.TEMPERATURE:
+                this.addMetadatum('temperature','K','House battery temperature', 
+                    (buff,offset=0)=>{
+                        const temp = buff.readUInt16LE(offset)
+                        if (temp==0xffff) 
+                            return null
+                        else 
+                            return temp / 100
+                    })
+                    break;
+            default:
+                break
+        }
+    }
+    static { 
+        this.metadata = new Map(super.getMetadata())
+        this.addMetadatum('meterType','', 'meter type', 
+                (buff)=>{return VC.MeterType.get( buff.readInt16LE(0))})
+        this.addMetadatum('voltage','','voltage',
+                (buff)=>{return buff.readInt16LE(2)/100})
+        this.addMetadatum('alarm','', 'alarm', 
+                (buff)=>{return buff.readUInt16LE(4)})
+        this.addMetadatum('current','A', 'current')    
+    }
+    emitValuesFrom(decData){
+        this.emitData("meterType",decData,0)
+        this.emitData("voltage",decData,2);
+        const alarm = this.getMetadatum("alarm").read(decData,4)
+        if (alarm>0){
+            this.emit(
+                `ALARM #${alarm} from ${this.getDisplayName()})`, 
+                { message: AlarmReason(alarm), state: 'alert'})
+        }
+        switch(this.auxMode){
+            case VC.AuxMode.STARTER_VOLTAGE:
+                this.emitData("starterVoltage",decData,6);
+                break;
+            case VC.AuxMode.TEMPERATURE:
+                this.emitData("temperature",decData,6);
+                break;
+            default:
+                break
+            }      
+        this.emit("current", this.getAuxModeAndCurrent(8,decData).current)
+  
+    }
+    
+
+}
+module.exports=VictronDCEnergyMeter 

package/sensor_classes/VictronGXDevice.js

@@ -0,0 +1,43 @@
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+const int24 = require('int24')
+class VictronGXDevice extends VictronSensor{
+/*
+Record layout is still to be determined and might change.
+Start
+bit
+Nr of
+bits Meaning Units Range NA value Remark
+0 0 32 16 Battery voltage 0.01 V 0 .. 655.34
+V
+0xFFFF VE_REG_DC_CHANNEL1_VOLTAGE
+2 16 48 20 PV power W 0 .. 1 MW 0xFFFFF VE_REG_DC_INPUT_POWER
+4 36 68 7 SOC 1% 0 .. 100% 0x7F VE_REG_SOC
+5 43 75 21 Battery power W -1 .. 1 MW 0x0FFFFF VE_REG_DC_CHANNEL1_POWER
+96 21 DC power W -1 .. 1 MW 0x0FFFFF
+TBD - AC in power
+TBD - AC out power
+TBD - Warnings /
+Alarms
+TBD
+117 43 Unuse
+*/
+    static async identify(device){
+        return await this.identifyMode(device, 0x07)
+    }   
+
+    static {
+        this.metadata = new Map(super.getMetadata())
+        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)})
+        this.addMetadatum('soc','ratio', 'state of charge', 
+            (buff)=>{ return ((buff.readUInt16BE(4)&0xfff)>>5)/100})
+        this.addMetadatum('batteryPower','W', 'battery power', 
+            (buff)=>{return (this.NaNif(int24.readInt24BE(buff,5)&0x1ffff),0x0FFFFF )})    
+        this.addMetadatum('DCPower','W', 'DCpower', 
+            (buff)=>{return this.NaNif(int24.readInt24BE(buff,8)>>3,0x0FFFFF )})    
+        }
+}
+module.exports=VictronGXDevice

package/sensor_classes/VictronInverter.js

@@ -0,0 +1,44 @@
+const VictronSensor = require("./Victron/VictronSensor");
+const VC=require("./Victron/VictronConstants.js")
+
+
+class VictronInverter extends VictronSensor{
+    static async identify(device){
+        return await this.identifyMode(device, 0x03)
+    }
+
+    static {
+        var md
+        this.metadata= new Map(super.getMetadata())
+        this.addMetadatum('deviceState','', 'inverter device state', 
+            (buff)=>{return VC.OperationMode.get(buff.readIntU8(0))})
+        md = this.addMetadatum('alarmReason','', 'reason for alarm',
+            (buff)=>{return buff.readIntU16LE(1)})
+        md.notify=true
+
+        this.addMetadatum('batteryVoltage','V', 'battery voltage', 
+            (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}
+        )
+                
+    }
+    powerFactor = .8 //parameterize anon
+
+    emitValuesFrom(decData){
+        super.emitValuesFrom(decData)
+        const alarm = this.getMetadatum("alarmReason").read(decData)
+        if (alarm>0){
+            this.emit(
+                `ALARM #${alarm} from ${this.getDisplayName()})`, 
+                { message: VC.AlarmReason.get(alarm), state: 'alert'})
+        }
+    }
+    
+
+}
+module.exports=VictronInverter

package/sensor_classes/VictronInverterRS.js

@@ -0,0 +1,44 @@
+const VictronSensor = require("./Victron/VictronSensor");
+const VC=require("./Victron/VictronConstants.js")
+
+function toBinaryString(buff){
+    return [...buff].map((b) => b.toString(2).padStart(8, "0")).join("");
+    }
+class VictronInverterRS extends VictronSensor{
+    static async identify(device){
+        return await this.identifyMode(device, 0x06)
+    }
+    
+
+    static {
+        var md
+        this.metadata= new Map(super.getMetadata())
+        this.addMetadatum('deviceState','', 'inverter device state', 
+                (buff)=>{return VC.OperationMode.get(buff.readIntU8(0))})
+        md = this.addMetadatum('chargerError','', 'charger error',
+                (buff)=>{return VC.ChargerError(buff.readIntU8(1))})
+        md.notify=true
+
+        this.addMetadatum('batteryVoltage','V', 'battery voltage', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(2),0x7FFF)/100})
+        this.addMetadatum('pvPower','W', 'PV power', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(4), 0xffff)})
+        this.addMetadatum('yieldToday','W', 'yield yoday in watts', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(6), 0xffff)*10})
+        this.addMetadatum('acOutPower','W', 'AC out power in watts', 
+            (buff)=>{this.NaNif(buff.readInt16LE(8), 0x7fff)})                
+    }
+
+    emitValuesFrom(decData){
+        super.emitValuesFrom(decData)
+        const error = this.getMetadatum("chargerError").read(decData)
+        if (error>0){
+            this.emit(
+                `Charger Error #${error} from ${this.getDisplayName()})`, 
+                { message: VC.ChargerError.get(error), state: 'error'})
+        }
+    }
+    
+
+}
+module.exports=VictronInverterRS

package/sensor_classes/VictronLynxSmartBMS.js

@@ -0,0 +1,50 @@
+/*(Lynx Smart) BMS (0x0A)
+Start Bit	Nr of Bits	Meaning	Units	Range	NA Value	Remark
+32	8	Error	0x0	VE_REG_BMS_ERROR		
+40	16	TTG	1min	0..45.5 days	0xFFFF	VE_REG_TTG
+56	16	Battery voltage	0.01V	-327.68..327.66 V	0x7FFF	VE_REG_DC_CHANNEL1_VOLTAGE
+72	16	Battery current	0.1A	-3276.8..3276.6	0x7FFF	VE_REG_DC_CHANNEL1_CURRENT
+88	16	IO status			0x0	VE_REG_BMS_IO
+104	18	Warnings/Alarms			0x0	VE_REG_BMS_WARNINGS_ALARMS
+122	10	SOC	0.1%	0..100.0%	0x3FF	VE_REG_SOC
+132	20	Consumed Ah	0.1Ah	-104,857..0 Ah	0xFFFFF	VE_REG_CAH Consumed Ah = -Record value
+152	7	Temperature	°C	-40..86 °C	0x7F	VE_REG_BAT_TEMPERATURE Temperature = Record value - 40
+159	1	Unused*/
+
+
+
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+const int24 = require('int24')
+
+class VictronLynxSmartBMS extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x0A)
+    }   
+
+    static {
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('error','', 'error code', 
+            (buff)=>{return buff.readUInt8(0)})
+ 
+        this.addMetadatum('ttg','s', 'time to go (in seconds)',
+            (buff)=>{return this.NaNif(buff.readUInt16LE(1),0xFFFF)*60})
+        this.addMetadatum('voltage','V', 'channel 1 voltage',
+            (buff)=>{return this.NaNif(buff.readInt16LE(3),0x7FFF)/100})
+        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})
+    }
+}
+module.exports=VictronLynxSmartBMS

package/sensor_classes/VictronOrionXS.js

@@ -0,0 +1,31 @@
+/*
+
+*/
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+class VictronOrionXS extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x0F)
+    }   
+    static {
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('deviceState','', 'device state', 
+            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+        this.addMetadatum('chargerError','', 'charger error',
+            (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
+        this.addMetadatum('outputVoltage','V', 'output voltage', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(2),0x7FF)/100})
+        this.addMetadatum('current','A','output current', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(4),0xFFFF)/10})
+        this.addMetadatum('inputVoltage','V', 'input voltage', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(6),0x07FF)/100})
+        this.addMetadatum('inputCurrent','A','input current', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(8),0xFFFF)/10})
+        this.addMetadatum('deviceOffReason','', 'device off reason', 
+            (buff)=>{return VC.OffReasons(buff.readUInt32(10))})    
+        }
+
+}
+module.exports=VictronOrionXS