bt-sensors-plugin-sk 1.1.0-beta.2.2.1.5 → 1.1.0-beta.2.2.3

package/sensor_classes/BlackListedDevice.js

@@ -1,31 +1,33 @@
 const BTSensor = require("../BTSensor");
-class BLACKLISTED extends BTSensor{
-    static isSystem = true
-    static async identify(device){
-        const md = await this.getDeviceProp(device,'ManufacturerData')
-        if (md){
-            const keys = Object.keys(md)
-            if (keys.length==1 && keys[0]==0x004C)
-                return this
+class BLACKLISTED extends BTSensor {
+    static isSystem = true;
+    static async identify(device) {
+        const md = await this.getDeviceProp(device, "ManufacturerData");
+        if (md && Object.hasOwn(md, 0x004c)){
+            if (md[0x004c].value.slice(0,2).join() != [0x02, 0x15].join()){ // iBeacons are exempt
+                return this;
+            }
+        return null;
         }
-        return null
     }
-    async init(){
-        await super.init()
-        this.currentProperties.Name= `Unsupported device from ${this.getManufacturer()}`
+
+    async init() {
+        await super.init();
+        this.currentProperties.Name = `Unsupported device from ${this.getManufacturer()}`;
     }
     reasonForBlacklisting() {
-        switch ( this.getManufacturerID()){
-            case (0x004C): return "Randomized MAC address (Apple)"
-            case (0x02e1): return "Device is using VE.Smart" //NOTE: Victron/VictronSensor class 
-                                                             //determines if a device is using VE.Smart
-                                                             //in identify(). If so, identify() returns
-                                                             //BlackListedDevice
-        
-            default: return ""
-            
-        }
+        switch (this.getManufacturerID()) {
+            case 0x004c:
+                return "Randomized MAC address (Apple)";
+            case 0x02e1:
+                return "Device is using VE.Smart"; //NOTE: Victron/VictronSensor class
+            //determines if a device is using VE.Smart
+            //in identify(). If so, identify() returns
+            //BlackListedDevice
 
+            default:
+                return "";
+        }
     }
 }
-module.exports=BLACKLISTED
+module.exports = BLACKLISTED;

package/sensor_classes/IBeacon.js

@@ -0,0 +1,42 @@
+const BTSensor = require("../BTSensor");
+
+class IBeacon extends BTSensor {
+    static isSystem = true;
+
+    static async identify(device) {
+        const md = await this.getDeviceProp(device,'ManufacturerData');
+        if (md && Object.hasOwn(md, 0x004c)) {
+            if (md[0x004c].value.slice(0,2).join() == [0x02, 0x15].join()) {
+            return this
+            }
+        }
+    return null
+    }
+
+    async init() {
+        await super.init();
+        this.initMetadata();
+    }
+
+    initMetadata(){
+        this.addMetadatum('battery','ratio', 'Battery charge state', (buffer)=>{return buffer[6]})
+    }
+
+    propertiesChanged(props){
+        super.propertiesChanged(props);
+        const buff = this.getServiceData("0000356e-0000-1000-8000-00805f9b34fb");
+        if (!buff)
+            throw new Error("Unable to get service data for " + this.getDisplayName());
+        this.emitData("battery", buff);
+    }
+
+    getManufacturer(){
+        return "Apple Inc. or clone";
+    }
+
+    getDescription(){
+        return `${this.getName()} iBeacon from Apple Inc. or a clone`
+    }
+}
+
+module.exports = IBeacon;

package/sensor_classes/JBDBMS.js

@@ -0,0 +1,170 @@
+const BTSensor = require("../BTSensor");
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+class JBDBMS extends BTSensor {
+
+  static TX_RX_SERVICE = "0000ff00-0000-1000-8000-00805f9b34fb"  
+  static NOTIFY_CHAR_UUID = "0000ff01-0000-1000-8000-00805f9b34fb"
+  static WRITE_CHAR_UUID  = "0000ff02-0000-1000-8000-00805f9b34fb"
+  
+  constructor(device,config,gattConfig){
+      super(device,config,gattConfig)
+      this.emitterFunctions=
+                [this.getAndEmitBatteryInfo.bind(this), 
+                this.getAndEmitCellVoltages.bind(this)]
+      
+  }
+  static identify(device){
+    return null
+  }
+  jbdCommand(command) {
+    return [0xDD, 0xA5, command, 0x00, 0xFF, 0xFF - (command - 1), 0x77]
+  }
+
+  async sendReadFunctionRequest( command ){    
+    return await this.txChar.writeValueWithResponse(Buffer.from(this.jbdCommand(command)))
+
+}
+  async init(){
+      await super.init()
+      this.addMetadatum('voltage', 'V', 'Total battery voltage', 
+        (buffer)=>{return buffer.readUInt16BE(4) / 100})
+      this.addMetadatum('current',  'A',  'Current flow',
+        (buffer)=>{return buffer.readInt16BE(6) / 100} )
+      this.addMetadatum('remainingCapacity', 'Ah',  'Remaining battery capacity', 
+        (buffer)=>{return buffer.readUInt16BE(8) / 100} )
+      this.addMetadatum('capacity', 'Ah',  'Battery capacity', 
+        (buffer)=>{return buffer.readUInt16BE(10) / 100} )
+      this.addMetadatum('cycles', '', 'cycles',
+        (buffer)=>{return buffer.readUInt16BE(12)} )
+      this.addMetadatum('protectionStatus', '', 'Protection Status',
+          (buffer)=>{return buffer.readUInt16BE(20)} )
+        
+      this.addMetadatum('SOC', 'ratio', 'State of Charge',
+        (buffer)=>{return buffer.readUInt8(23)/100} )
+      
+      this.addMetadatum('FET', '', 'FET Control',
+          (buffer)=>{return buffer.readUInt8(24)} )
+  
+      await this.device.connect()
+      await this.initCharacteristics()
+      const cellsAndTemps = await this.getNumberOfCellsAndTemps()
+      this.numberOfCells=cellsAndTemps.cells
+      this.numberOfTemps=cellsAndTemps.temps
+
+      for (let i=0; i<this.numberOfTemps; i++){
+        this.addMetadatum(`temp${i}`, 'K', `Temperature${i+1} reading`,
+          (buffer)=>{
+            return buffer.readUInt16BE(27+(i*2))/10
+          })
+      }
+      
+      for (let i=0; i<this.numberOfCells; i++){
+        this.addMetadatum(`cell${i}Voltage`, 'V', `Cell ${i+1} voltage`,
+          (buffer)=>{return buffer.readUInt16BE((4+(i*2)))/1000} )
+        this.addMetadatum(`cell${i}Balance`, 'V', `Cell ${i+1} balance` )
+      }
+
+
+    }
+  hasGATT(){
+    return true
+  }
+  initCharacteristics(){ 
+    return new Promise((resolve,reject )=>{ this.device.connect().then(async ()=>{ 
+      const gattServer = await this.device.gatt()
+      const txRxService= await gattServer.getPrimaryService(this.constructor.TX_RX_SERVICE)
+      this.rxChar = await txRxService.getCharacteristic(this.constructor.NOTIFY_CHAR_UUID)
+      this.txChar = await txRxService.getCharacteristic(this.constructor.WRITE_CHAR_UUID)
+      await this.rxChar.startNotifications()
+      resolve(this)
+    }) .catch((e)=>{ reject(e.message) }) }) 
+  }
+
+  async initGATTNotifications(){
+    this.intervalID = setInterval(()=>{
+        this.emitGATT()
+    }, 1000*(this?.pollFreq??60) )
+  }
+
+  emitGATT(){
+    this.getAndEmitBatteryInfo()
+    setTimeout(()=>{this.getAndEmitCellVoltages()}, 5000)
+  }
+
+  async getNumberOfCellsAndTemps(){
+    var b = await this.getBuffer(0x3)
+    return {cells:b[25], temps:b[26]}
+  }  
+  
+  getBuffer(command){
+
+    return new Promise( async ( resolve, reject )=>{
+        const r = await this.sendReadFunctionRequest(command)
+        const result = Buffer.alloc(256)
+        var offset = 0
+
+        const timer = setTimeout(() => {
+          clearTimeout(timer)
+          reject(new Error(`Response timed out from JBDBMS device ${this.getName()}. `));
+        }, 30000);
+
+        const valChanged = async (buffer) => {
+          this.debug(buffer)
+          buffer.copy(result,offset)
+          if (buffer[buffer.length-1]==0x77){
+            this.rxChar.removeAllListeners()
+            clearTimeout(timer)
+            resolve(result)
+          }
+          offset+=buffer.length
+        }
+
+
+        this.rxChar.on('valuechanged', valChanged )
+    })
+} 
+
+async initGATTConnection() {
+  return this  
+}
+
+getAndEmitBatteryInfo(){
+  this.getBuffer(0x03).then((buffer)=>{
+    (["current", "voltage", "remainingCapacity", "capacity","cycles", "protectionStatus", "SOC","FET",]).forEach((tag) =>
+      this.emitData( tag, buffer )
+    )
+    for (let i = 0; i<this.numberOfTemps; i++){
+      this.emitData(`temp${i}`,buffer)    
+    }
+    const balances = buffer.readUInt32BE(16)
+
+    for (let i = 0; i<this.numberOfCells; i++){
+      this.emit(`cell${i}Balance`,(1<<i & balances)?1:0)
+    }
+  })
+}
+
+getAndEmitCellVoltages(){
+  this.getBuffer(0x4).then((buffer)=>{
+    for (let i=0; i<this.numberOfCells; i++){
+      this.emitData(`cell${i}Voltage`,buffer)
+  }})
+}
+
+initGATTInterval(){
+  this.initGATTNotifications()
+}
+
+async stopListening(){
+  super.stopListening()
+  this.rxChar.stopNotifications()
+  await this.device.disconnect()
+}
+  
+}
+
+module.exports = JBDBMS;

package/sensor_classes/LancolVoltageMeter.js

@@ -0,0 +1,39 @@
+const BTSensor = require("../BTSensor");
+
+class LancolVoltageMeter extends BTSensor{
+
+    static async  identify(device){
+
+        const name = await this.getDeviceProp(device,"Name")
+        const regex = /^Lancol *[0-9]{1,3}\.[0-9]{1,2}V/
+ 
+        if (name && name.match(regex))  
+            return this
+        else
+            return null
+        
+    }
+
+    async init(){
+        await super.init()
+        this.addMetadatum('voltage','V', 'battery voltage')
+    }
+
+    getManufacturer(){
+        return "Lancol"
+    }
+    async propertiesChanged(props){
+        super.propertiesChanged(props)    
+        
+        if (props.Name) {
+            const regex = /[+-]?([0-9]*[.])?[0-9]+/
+            const r = this.valueIfVariant(props.Name).match(regex)
+            if (r) {
+                this.emit("voltage",parseFloat([...r][0]))
+            } else {
+                this.debug(`Unable to parse Name property for ${this.getName()}: ${props.Name}`)
+            }
+        }
+   }                         
+}
+module.exports=LancolVoltageMeter

package/sensor_classes/RenogyBattery.js

@@ -77,8 +77,8 @@ class RenogyBattery extends RenogySensor {
 
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["current", "voltage", "remainingCharge", "capacity"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["current", "voltage", "remainingCharge", "capacity"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })
@@ -87,7 +87,7 @@ class RenogyBattery extends RenogySensor {
     
     getAndEmitCellVoltages(){
         return new Promise( async ( resolve, reject )=>{
-            this.sendReadFunctionRequest(0x1388,0x11)
+            await this.sendReadFunctionRequest(0x1388,0x11)
 
             this.readChar.once('valuechanged', (buffer) => {
                 for (let i = 0; i++ ; i < this.numberOfCells) 
@@ -99,7 +99,7 @@ class RenogyBattery extends RenogySensor {
 
     getAndEmitCellTemperatures(){
         return new Promise( async ( resolve, reject )=>{
-            this.sendReadFunctionRequest(0x1399,0x22)
+            await this.sendReadFunctionRequest(0x1399,0x22)
 
             this.readChar.once('valuechanged', buffer => {
                 for (let i = 0; i++ ; i < this.numberOfCells) 

package/sensor_classes/RenogyInverter.js

@@ -63,8 +63,8 @@ class RenogyInverter extends RenogySensor {
             await this.sendReadFunctionRequest(0xfa0, 0x8)
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["ueiVoltage","ueiCurrent", "voltage", "loadCurrent", "frequency","temperature"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["ueiVoltage","ueiCurrent", "voltage", "loadCurrent", "frequency","temperature"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })
@@ -77,8 +77,8 @@ class RenogyInverter extends RenogySensor {
             await this.sendReadFunctionRequest(0x10e9, 0x5)
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["solarVoltage","solarCurrent", "solarPower", "solarChargingStatus", "solarChargingPower"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["solarVoltage","solarCurrent", "solarPower", "solarChargingStatus", "solarChargingPower"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })
@@ -91,8 +91,8 @@ class RenogyInverter extends RenogySensor {
             await this.sendReadFunctionRequest(0x113a, 0x2)
         
             this.readChar.once('valuechanged', (buffer) => {
-                ["loadPower", "chargingCurrent"].forEach(tag)
-                    this.emitData( tag, buffer )
+                ["loadPower", "chargingCurrent"].forEach((tag)=>
+                    this.emitData( tag, buffer ))
                 
                 resolve(this)
             })

package/sensor_classes/ShellySBHT003C.js

@@ -0,0 +1,109 @@
+const BTHomeServiceData = require("./BTHome/BTHomeServiceData");
+const AbstractBTHomeSensor = require("./BTHome/AbstractBTHomeSensor");
+
+/**
+ * Sensor class representing the Shelly BLU H&T.
+ *
+ * This sensor is publishing data utilising the BTHome format and inherits from {@link AbstractBTHomeSensor}.
+ */
+class ShellySBHT003C extends AbstractBTHomeSensor {
+	/**
+	 * The shortened local name as advertised by the Shelly BLU H&T.
+	 * @type {string}
+	 */
+	static SHORTENED_LOCAL_NAME = "SBHT-003C";
+
+	async init() {
+		await super.init();
+		this.initMetadata();
+	}
+
+	/**
+	 * @typedef ButtonPressEvent {string}
+	 */
+	/**
+	 * The Shelly BLU H&T only supports single press and hold press options.
+	 * @type {Readonly<{PRESS: string, HOLD_PRESS: string}>}
+	 */
+	static ButtonPressEvent = Object.freeze({
+		PRESS: "press",
+		HOLD_PRESS: "hold_press",
+	});
+
+	/**
+	 * Returns the `ShellySBHT003C` sensor class if the specified device has been identified as Shelly BLU H&T.
+	 *
+	 * @param device The Bluetooth device to be identified.
+	 * @returns {Promise<ShellySBHT003C|null>} Returns the sensor class if the device has been identified, or null.
+	 */
+	static async identify(device) {
+		if (
+			(await ShellySBHT003C.hasBtHomeServiceData(device)) &&
+			(await ShellySBHT003C.hasName(
+				device,
+				ShellySBHT003C.SHORTENED_LOCAL_NAME,
+			))
+		) {
+			return ShellySBHT003C;
+		}
+		return null;
+	}
+
+	/**
+	 * Parses the relevant button press events for the Shelly BLU H&T from the specified BTHome data. This device only
+	 * uses a subset of all available BTHome button press events.
+	 *
+	 * @param btHomeData {BTHomeServiceData.BthomeServiceData} The BTHome data provided by the device.
+	 * @returns {ShellySBHT003C.ButtonPressEvent|null} The device's button state.
+	 * @see https://shelly-api-docs.shelly.cloud/docs-ble/Devices/ht/#button-press-events
+	 * @see https://bthome.io/format/
+	 */
+	static parseShellySBHT003CButton(btHomeData) {
+		const buttonEvent = ShellySBHT003C.parseButton(btHomeData);
+		if (buttonEvent) {
+			if (buttonEvent === BTHomeServiceData.ButtonEventType.PRESS) {
+				return ShellySBHT003C.ButtonPressEvent.PRESS;
+				/*
+				 * Prior to firmware version 1.0.20, the hold press event is indicated by 0xFE, which does
+				 * not conform with the BTHome standard.
+				 */
+			}
+			if (
+				buttonEvent === BTHomeServiceData.ButtonEventType.HOLD_PRESS ||
+				buttonEvent === 0xfe
+			) {
+				return ShellySBHT003C.ButtonPressEvent.HOLD_PRESS;
+			}
+		}
+		return null;
+	}
+
+	initMetadata() {
+		this.addMetadatum(
+			"battery",
+			"ratio",
+			"battery level",
+			ShellySBHT003C.parseBatteryLevel,
+		);
+		this.addMetadatum(
+			"temp",
+			"K",
+			"temperature",
+			ShellySBHT003C.parseTemperature,
+		);
+		this.addMetadatum(
+			"humidity",
+			"ratio",
+			"humidity",
+			ShellySBHT003C.parseHumidity,
+		);
+		this.addMetadatum(
+			"button",
+			"enum",
+			"button",
+			ShellySBHT003C.parseShellySBHT003CButton,
+		);
+	}
+}
+
+module.exports = ShellySBHT003C;

package/sensor_classes/VictronBatteryMonitor.js

@@ -78,13 +78,13 @@ class VictronBatteryMonitor extends VictronSensor{
                 break;
             case VC.AuxMode.MIDPOINT_VOLTAGE:
                 this.addMetadatum('midpointVoltage','V', 'midpoint battery voltage', 
-                    (buff,offset=0)=>{return buff.readInt16LE(offset)/100},
+                    (buff,offset=0)=>{return buff.readUInt16LE(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)/1000)+273.15},
+                    (buff,offset=0)=>{return (buff.readUInt16LE(offset)/100)},
                     '6597ed7d-4bda-4c1e-af4b-551c4cf74769')
                 break;
             default:
@@ -114,7 +114,7 @@ class VictronBatteryMonitor extends VictronSensor{
         default:
             break
         }
-        this.emit("current", (this.NaNif(int24.readInt24LE(decData,  8)>>2,0x3FFFFF))/1000)  
+        this.emit("current", (this.NaNif(int24.readInt24LE(decData,  8)>>2,0x1FFFFF))/1000)  
         this.emit("consumed",(this.NaNif(int24.readInt24LE(decData, 11)&0xFFFFF,0xFFFFF)) / 10) ; 
         this.emit("soc", this.NaNif(((decData.readUInt16LE(13)& 0x3FFF)>>4),0x3FF)/1000)
         

package/sensor_classes/XiaomiMiBeacon.js

@@ -2,7 +2,6 @@ const BTSensor = require("../BTSensor");
 
 const crypto = require('crypto');
 const util = require('util');
-const { isGeneratorFunction } = require("util/types");
 
 const DEVICE_TYPES = new Map([
     [0x0C3C, { name: "Alarm Clock", model: "CGC1" }],