bt-sensors-plugin-sk 1.2.5 → 1.2.6-beta-1

package/sensor_classes/EcoWorthy.js

@@ -0,0 +1,160 @@
+const BTSensor = require("../BTSensor");
+({FakeDevice,FakeGATTService,FakeGATTCharacteristic }=require( "../development/FakeBTDevice.js"))
+//a1000000650000000000180103440018004800640531ff8000002710000100010000000000000000000100020000ffff00000000000000000000000000000000000000000000000000000000000000000000418b
+//a20000006500000000001801035600040cfb0cfd0cfb0cfaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000300cd00c000befc18fc18fc18fc18fc18fc18976a
+
+/*
+        BMSdp("battery_level", 16, 2, False, lambda x: x, 0xA1),
+        BMSdp("voltage", 20, 2, False, lambda x: x / 100, 0xA1),
+        BMSdp("current", 22, 2, True, lambda x: x / 100, 0xA1),
+        BMSdp("problem_code", 51, 2, False, lambda x: x, 0xA1),
+        BMSdp("design_capacity", 26, 2, False, lambda x: x // 100, 0xA1),
+        BMSdp("cell_count", _CELL_POS, 2, False, lambda x: x, 0xA2),
+        BMSdp("temp_sensors", _TEMP_POS, 2, False, lambda x: x, 0xA2),
+        # ("cycles", 0xA1, 8, 2, False, lambda x: x),
+*/
+
+function waitForVariable(obj, variableName, interval = 100) {
+  return new Promise((resolve) => {
+    if (obj[variableName] !== undefined) {
+      return resolve(obj[variableName]);
+    }
+
+    const intervalId = setInterval(() => {
+      if (obj[variableName] !== undefined) {
+        clearInterval(intervalId);
+        resolve(obj[variableName]);
+      }
+    }, interval);
+  });
+}
+
+class EcoWorthy extends BTSensor {
+      static Domain = BTSensor.SensorDomains.electrical
+
+  static TX_RX_SERVICE = "0000fff0-0000-1000-8000-00805f9b34fb"  
+  static NOTIFY_CHAR_UUID = "0000fff1-0000-1000-8000-00805f9b34fb"
+
+   static async test(data=["a1000000650000000000180103440018004800640531ff8000002710000100010000000000000000000100020000ffff00000000000000000000000000000000000000000000000000000000000000000000418b",
+                    "a20000006500000000001801035600040cfb0cfd0cfb0cfaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000300cd00c000befc18fc18fc18fc18fc18fc18976a"
+  ]){
+     const device = new FakeDevice(
+      [new FakeGATTService("0000fff0-0000-1000-8000-00805f9b34fb",
+        [new FakeGATTCharacteristic("0000fff1-0000-1000-8000-00805f9b34fb",
+          data
+        )]
+      )]
+     )
+     const obj = new EcoWorthy(device)
+     obj.currentProperties={Name:"Fake EcoWorthy", Address:"<mac>"}
+     obj.debug=(m)=>{console.log(m)}
+     obj.deviceConnect=()=>{}
+    await obj.initSchema()
+    for (const [tag,path] of Object.entries(obj._schema.properties.paths.properties)) {
+      obj.on(tag, val=>{console.log(`${tag} => ${val} `)})
+    }
+
+  }
+  
+  static identify(device){
+    return null
+  }
+  static ImageFile = "EcoWorthy.webp"
+
+
+  async initSchema(){
+      super.initSchema()
+      this.addDefaultParam("batteryID")
+     
+      this.addDefaultPath('voltage','electrical.batteries.voltage')
+        .read=
+        (buffer)=>{return buffer.readUInt16BE(20) / 100}
+
+      this.addDefaultPath('current','electrical.batteries.current')
+        .read=
+        (buffer)=>{return buffer.readInt16BE(22) / 100} 
+      
+      this.addDefaultPath('remainingCapacity','electrical.batteries.capacity.remaining')
+        //.read=(buffer)=>{return (buffer.readUInt16BE(8) / 100)*3600} 
+      
+      this.addDefaultPath('capacity','electrical.batteries.capacity.actual')
+        .read=(buffer)=>{return (buffer.readUInt16BE(26) / 100)*3600} 
+     
+        this.addDefaultPath('SOC','electrical.batteries.capacity.stateOfCharge')
+        .read=(buffer)=>{return buffer.readUInt16BE(16)/100} 
+  
+        await this._initGATTConnection()
+        await this._initGATTNotifications()
+        await waitForVariable(this,"numberOfTemps")
+        await waitForVariable(this,"numberOfCells")
+
+      for (let i=0; i<this.numberOfTemps; i++){
+        this.addMetadatum(`temp${i}`, 'K', `Temperature${i+1} reading`,
+          (buffer)=>{
+            return buffer.readUInt16BE(82+(i*2))/10
+          })
+         .default=`electrical.batteries.{batteryID}.Temperature${i+1}`
+      }
+      
+      for (let i=0; i<this.numberOfCells; i++){
+        this.addMetadatum(`cell${i}Voltage`, 'V', `Cell ${i+1} voltage`,
+          (buffer)=>{return buffer.readUInt16BE((16+(i*2)))/1000} )
+          .default=`electrical.batteries.{batteryID}.cell${i+1}.voltage`
+      }
+  }
+
+  hasGATT(){
+    return true
+  }
+
+  async _initGATTNotifications(){
+      await this.rxChar.startNotifications()
+      
+      this.rxChar.on("valuechanged", (buffer)=>{
+        if (buffer[0]==0xA1){
+           (["current", "voltage", "remainingCapacity", "capacity", "SOC" ]).forEach((tag) =>
+             this.emitData( tag, buffer )
+            )
+        } else 
+          if (buffer[0]==0xA2){
+            
+            if (!this.numberOfCells){
+              this.numberOfCells=buffer[15]
+            }      
+            if (!this.numberOfTemps){
+              this.numberOfTemps=buffer[81]
+            }
+            for (let i=0;i<this.numberOfCells;i++){
+              this.emitData(`cell${i+1}Voltage`, buffer)
+            }
+            for (let i=0;i<this.numberOfTemps;i++){
+              this.emitData(`temp${i+1}`, buffer)
+                      
+            }    
+          }
+      })
+  }
+async _initGATTConnection() {
+   await this.deviceConnect() 
+   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)
+  return this  
+}
+
+async init(){
+  
+  return await super.init()
+
+}
+
+async stopListening(){
+  super.stopListening()
+  if (this.rxChar) 
+    this.rxChar.stopNotifications()
+  if (this.device)
+    await this.device.disconnect()
+}
+  
+}
+module.exports = EcoWorthy;

package/sensor_classes/EctiveBMS.js

@@ -0,0 +1,269 @@
+const BTSensor = require("../BTSensor");
+const EventEmitter = require('node:events');
+
+
+const testData=[
+  ['5e 43',
+  '34',                                                        
+  '33 33 30 30 30 30 44 32 46 37 46 46 46 46 34 38',
+  '45 38 30 31 30 30 30 45 30 30 34 41',              
+  '30 30 39 30 30 42 30 30 38 30 30 37 42 34 45 44',  
+  '30 43 46 30 30 43 46 32 30 43 46 35 30 43 30 30', 
+  '30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30',  
+  '30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30',
+  '30 30 30 30 30 30 30 30 30 30 30 30',                  
+  '30 30 30 43 31 31 00 00 00 00 00 00 00 00'],
+  ["5e 35 34 33 37 30 30 30 30 30 30 30 30 30 30 30 30",
+   "34 38 45 38 30 31 30 30 31 30 30 30 36 33 30 30",
+   "43 30 30 42 30 30 38 30 38 37 46 34",
+   "33 41 30 45 30 35 30 45 30 33 30 45 30 46 30 44",
+   "30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30",
+   "30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30",
+   "30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30",
+   "30 35 37 44 00 00 00 00 00 00 00 00"
+  ],
+  //bad data (!=0x21)
+  ["5e 35 34 33 37 30 30 30 30 30 30 30 30 30 30 30 30", 
+   "34 38 45 38 30 21 30 30 31 30 30 30 36 33 30 30", 
+   "43 30 30 42 30 30 38 30 38 37 46 34",
+   "33 41 30 45 30 35 30 45 30 33 30 45 30 46 30 44",
+   "30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30",
+   "30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30",
+   "30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30",
+   "30 35 37 44 00 00 00 00 00 00 00 00"
+  ]
+]
+class EctiveDataManager extends EventEmitter{
+  static expectedLength = 120
+  static ImageFile = "TopbandBattery.webp"
+  buffer = Buffer.from([])
+  
+  delimitedAt(data){
+    const delimiters = [0x5e,0xaf] 
+    for (const d of delimiters){
+      if (data.includes(d)) return data.indexOf(d)
+    }
+    return -1
+  }
+
+  add(buff) {
+      
+      const delimiterIndex = this.delimitedAt(buff)
+      if (delimiterIndex == 0)
+        this.buffer= buff.subarray(1)
+      else {
+        if (delimiterIndex==-1)
+          this.buffer=Buffer.concat([this.buffer, buff])
+        else {
+          this.buffer=Buffer.concat([this.buffer,buff.subarray(0, delimiterIndex)])
+        }
+      }
+      if ( this.buffer.length==this.constructor.expectedLength) {
+        const _data = new EctiveData (this.buffer)
+        if (_data.error) {
+          this.buffer=Buffer.from([])
+          throw new Error (`malformed packet: ${JSON.parse(JSON.stringify(_data)).ascii}`)
+        }
+        else {
+          this.emit("valuechanged", _data.hex )
+          this.buffer=Buffer.from([])
+        }
+      } else {
+        if (delimiterIndex>0) {
+          this.buffer=buff.subarray(delimiterIndex+1)
+        }
+      }
+
+  
+    }
+}
+
+class EctiveData{
+  constructor(data){
+    this.ascii = data.toString("utf8").slice(0,data.indexOf(0)) 
+    this.hex = Buffer.from(this.ascii,"hex")
+    this.error = !this.verify()
+  }
+  
+  verify(){
+    return (this.hex.length==this.ascii.toString("utf8").length/2) 
+  }
+}
+class EctiveBMS extends BTSensor {
+  static Domain = BTSensor.SensorDomains.electrical
+
+  static RX_SERVICE = "0000ffe0-0000-1000-8000-00805f9b34fb"  
+  static NOTIFY_CHAR_UUID = "0000ffe4-0000-1000-8000-00805f9b34fb"
+  static test(data, numCells=4){
+    const obj = new EctiveBMS()
+    obj.currentProperties={Name:"Topbrand BMS", Address:"<mac>"}
+    obj.numberOfCells=numCells
+    obj.initSchema()
+    obj.debug=(m)=>{console.log(m)}
+    for (const [tag,path] of Object.entries(obj._schema.properties.paths.properties)) {
+      obj.on(tag, val=>{console.log(`${tag} => ${val} `)})
+    }
+      obj._dataManager.on("valuechanged", (b)=>{
+        obj.emitValuesFrom(b)
+      })
+      data.forEach(d => {
+      const _d=d.replaceAll(" ","").toLowerCase()
+      const b=Buffer.from(_d,"hex")
+      try {
+        obj._dataManager.add(b)
+      } catch (e){
+        obj.debug(`(${obj.getName()}): ${e.message}`)
+      }
+    });
+  }
+  static testStream(filename, numCells=4){
+    const obj = new EctiveBMS()
+    obj.currentProperties={Name:"Topbrand BMS", Address:"<mac>"}
+    obj.numberOfCells=numCells
+    obj.initSchema()
+    obj.debug=(m)=>{console.log(m)}
+    for (const [tag,path] of Object.entries(obj._schema.properties.paths.properties)) {
+      obj.on(tag, val=>{console.log(`${tag} => ${val} `)})
+    }
+      obj._dataManager.on("valuechanged", (b)=>{
+        obj.emitValuesFrom(b)
+      })
+      const lineReader = require('readline').createInterface({  input: require('fs').createReadStream(filename)});
+    // Each line in input.txt will be successively available here as `line`.
+  
+    (async ()=>{for await (const line of lineReader) {
+      const _d = line.slice(0,50).replaceAll(" ","").toLowerCase()
+      const b=Buffer.from(_d,"hex")
+      try {
+        obj._dataManager.add(b)
+      } catch (e){
+        obj.debug(`(${obj.getName()}): ${e.message}`)
+      }
+    }})()
+  }
+    
+  static DisplayName(){
+    return "EctiveBMS: Topbrand, Skanbatt and other LiFePo4 batteries"
+  }
+  static identify(device){
+    return null
+  }
+
+  _dataManager = new EctiveDataManager()
+  initSchema(){
+      super.initSchema()
+      this.addDefaultParam("batteryID")
+      this.addParameter(
+        "numberOfCells",
+        {
+                title:'number of cells in battery',
+                type: 'integer',
+                default: 4,
+                isRequired: true
+            }
+      )
+     
+      this.addDefaultPath('voltage','electrical.batteries.voltage')
+        .read=
+        (buffer)=>{return buffer.readUInt32LE(0) / 1000}
+
+      this.addDefaultPath('current','electrical.batteries.current')
+        .read=
+        (buffer)=>{return buffer.readInt32LE(4) / 1000} 
+
+       this.addMetadatum(`cycleCharge`, 'C', `cycle charge`,
+          (buffer)=>{
+            return 3600*(buffer.readUInt32LE(8)/1000)
+          })
+         .default='electrical.batteries.{batteryID}.cycleCharge'
+
+
+       this.addMetadatum('cycleCount', '', 'number of cycles',
+          (buffer)=>{
+            return buffer.readUInt16LE(12)
+          })
+         .default='electrical.batteries.{batteryID}.cycles'
+
+      this.addDefaultPath('SOC','electrical.batteries.capacity.stateOfCharge')
+        .read=(buffer)=>{return buffer.readUInt16LE(14)/100} 
+      
+        this.addMetadatum('temp', 'K', 'Temperature reading',
+          (buffer)=>{
+            return buffer.readUInt16LE(16)/10
+          })
+         .default='electrical.batteries.{batteryID}.temperature'
+
+
+        this.addMetadatum('flags', '', 'Problem flags',
+          (buffer)=>{
+            return buffer.readUInt16LE(18).toString('2').padStart(16,'0')
+          })
+         .default='electrical.batteries.{batteryID}.problemFlags'
+      
+      
+      for (let i=0; i<this?.numberOfCells??4; i++){
+        this.addMetadatum(`cell${i+1}Voltage`, 'V', `Cell ${i+1} voltage`,
+          (buffer)=>{return buffer.readUInt16LE((22+(i*2)))/1000} )
+          .default=`electrical.batteries.{batteryID}.cell${i+1}.voltage`
+      }
+  }
+
+  hasGATT(){
+    return true
+  }
+
+
+usingGATT(){
+      return true
+}
+
+emitGATT(){
+  //do nothing
+}
+
+  verifyData(d1,d2){
+          if (d1.length!==d2.toString("utf8").length/2) {
+            this._dataError=true
+            this.debug(`(${this.getName()}) malformed packet received: ${d2.toString()}`)
+          }
+          return !this._dataError
+  }
+
+
+  async initGATTNotifications(){
+         await this.rxChar.startNotifications()
+         this.debug(`(${this.getName()}) Notifications started`)
+
+         this.rxChar.on("valuechanged", (buffer)=>{
+            try {
+              this._dataManager.add(buffer)
+            } catch (e){
+              this.debug(`(${this.getName()}): ${e.message}`)
+            }
+         })
+        this._dataManager.on("valuechanged", (b)=>{
+          this.emitValuesFrom(b)
+        } )
+  }
+
+  async initGATTConnection() {
+     
+        await this.deviceConnect() 
+        const gattServer = await this.device.gatt()
+        const rxService= await gattServer.getPrimaryService(this.constructor.RX_SERVICE)
+        this.rxChar = await rxService.getCharacteristic(this.constructor.NOTIFY_CHAR_UUID)
+
+}
+
+
+async stopListening(){
+  super.stopListening()
+  if (this.rxChar) 
+    this.rxChar.stopNotifications()
+  if (this.device)
+    await this.device.disconnect()
+}
+  
+}
+
+module.exports = EctiveBMS;

package/sensor_classes/FeasyComBeacon.js

@@ -0,0 +1,68 @@
+
+const BTSensor = require("../BTSensor");
+const Eddystone = require("./Beacon/Eddystone")
+const iBeacon = require("./Beacon/iBeacon")
+
+class FeasyComBeacon extends BTSensor {
+
+    static async identify (device){
+      return null
+    }
+    static IsRoaming = true;
+    static Domain = BTSensor.SensorDomains.beacons
+    static ImageFile = "BP108B.webp"
+    
+    initSchema(){
+        super.initSchema()
+        this.addParameter("beaconType",
+            {
+                title:"type of beacon",
+                enum: ["Eddystone", "iBeacon"],
+                isRequired: true,
+                default:"EddyStone"
+            }
+        )
+        this.beacon.initSchema()
+    }
+
+    async init(){
+      const bt = this?.beaconType??"Eddystone"
+      if (bt=="Eddystone") {
+        
+        this.beacon=new Eddystone(this)
+
+      }
+      else 
+        if (bt=="iBeacon")
+          this.beacon=new iBeacon(this)
+        else
+          throw new Error (`(${this.getName()}) Unknown Beacon Type: ${bt}`)
+
+      await super.init()
+
+    }
+
+    initListen(){
+      super.initListen()
+      this.beacon.initListen()
+
+    }
+    elapsedTimeSinceLastContact(){
+      
+      return this.beacon.elapsedTimeSinceLastContact(super.elapsedTimeSinceLastContact())
+    }
+
+    propertiesChanged(props){
+      super.propertiesChanged(props);
+      this.beacon.propertiesChanged(props) 
+    }
+
+    getManufacturer(){
+        return "FeasyCom Inc.";
+    }
+    getTextDescription(){
+        return `${this.getName()} iBeacon/Eddystone device`
+    }
+}
+
+module.exports = FeasyComBeacon;

package/sensor_classes/GobiusCTankMeter.js

@@ -261,6 +261,8 @@ class GobiusCTankMeter extends BTSensor{
         else
             return null
     }
+    static ImageFile = "GobiusCTankMeter.png"
+    
     hasGATT(){
         return true
     }
@@ -274,6 +276,7 @@ class GobiusCTankMeter extends BTSensor{
         )
 
     }
+
      initSchema(){
         super.initSchema()
         this.getGATTParams()["useGATT"].default=true
@@ -351,9 +354,7 @@ class GobiusCTankMeter extends BTSensor{
             })
         }))
     }
-    getDescription(){
-        return '<a href="https://gobiusc.com/"><img src="../bt-sensors-plugin-sk/images/Gobius_C.png" alt="Gobius C Tank Measure" "></a>'
-    }
+
     async stopListening(){
         super.stopListening()
         if (this.characteristic  && await this.characteristic.isNotifying()) {

package/sensor_classes/GoveeH5074.js

@@ -4,6 +4,8 @@ class GoveeH5074 extends  GoveeSensor {
     static getIDRegex() {
         return /^Govee_H5074_[a-f,A-F,0-9]{4}$/
     }
+    static ImageFile = "GoveeH5074.jpg"
+
     initSchema(){
         super.initSchema()
         this.addDefaultParam("zone")

package/sensor_classes/GoveeH5075.js

@@ -15,6 +15,8 @@ class GoveeH5075 extends  GoveeSensor {
         sensor.emitValuesFrom(Buffer.from([0x00,0x03,0xbb,0x94,0x64,0x00]))
 
     }
+    static ImageFile = "GoveeH5075.webp"
+
     initSchema(){
         super.initSchema()
         this.addDefaultParam("zone")

package/sensor_classes/GoveeH510x.js

@@ -17,6 +17,7 @@ class GoveeH510x extends GoveeSensor{
 
     }
     static DATA_ID = 0x0001
+    static ImageFile = "GoveeH510x.jpg"
     initSchema(){
         super.initSchema()
         this.addDefaultParam("zone")

package/sensor_classes/Inkbird.js

@@ -12,6 +12,7 @@ class Inkbird extends BTSensor{
             return null
         
     }
+    static ImageFile = "InkbirdTH3.jpg"
 
     initSchema() {
         super.initSchema()

package/sensor_classes/JBDBMS.js

@@ -29,6 +29,7 @@ class JBDBMS extends BTSensor {
   static identify(device){
     return null
   }
+  static ImageFile = "JBDBMS.webp"
 
   jbdCommand(command) {
     return [0xDD, 0xA5, command, 0x00, 0xFF, 0xFF - (command - 1), 0x77]

package/sensor_classes/Junctek.js

@@ -21,19 +21,27 @@ class JunctekBMS extends BTSensor{
 
         return null
     }
+    static ImageFile = "Junctek.webp"
 
-    chargeDirection = 1 
+    chargeDirection = 0
 
     hasGATT(){
         return true
     }
 
-
-
     async initSchema(){
         super.initSchema()
         this.addDefaultParam("batteryID")
 
+        this.addParameter("capacityAh",
+            {
+                title:"battery capacity in Ah",
+                type:"integer",
+                isRequired: true,
+                default: 200
+            }
+        )
+
         this.addDefaultPath("voltage","electrical.batteries.voltage")
             
         this.addDefaultPath("current","electrical.batteries.current")
@@ -78,16 +86,15 @@ class JunctekBMS extends BTSensor{
                     break
                 
                 case 0xC1:
-                    emitObject["current"]=()=>{return (v/100)*this.chargeDirection}
+                    if (this.chargeDirection)
+                        emitObject["current"]=()=>{return (v/100)*this.chargeDirection}
                     break
 
                 case 0xD1:
-                    this.debug(v)
                     if (v==0)
                         this.chargeDirection=-1
                     else 
                         this.chargeDirection= 1
-                    this.debug(this.chargeDirection)
                     break
 
                 case 0xD2:
@@ -125,6 +132,7 @@ class JunctekBMS extends BTSensor{
                     break
                 case 0xB1:
                     emitObject["capacityActual"]=v /10
+                    emitObject["soc"]=(this.capacityAh/(emitObject["capacityActual"]))/100
                     break
             }
             }

package/sensor_classes/KilovaultHLXPlus.js

@@ -41,6 +41,7 @@ class KilovaultHLXPlus extends BTSensor{
         super(device, config, gattConfig)
         this.accumulated_buffer = Buffer.alloc(0)
     }
+    static ImageFile = "KilovaultHLXPlus.jpg"
 
     static async identify(device){
         const regex = /^\d\d\-(12|24|36)00HLX\+\d{4}/

package/sensor_classes/LancolVoltageMeter.js

@@ -3,6 +3,8 @@ const BTSensor = require("../BTSensor");
 class LancolVoltageMeter extends BTSensor{
 
     static Domain = BTSensor.SensorDomains.electrical
+    static ImageFile = "LancolVoltageMeter.webp"
+
     static async  identify(device){
 
         const name = await this.getDeviceProp(device,"Name")

package/sensor_classes/MercurySmartcraft.js

@@ -26,6 +26,7 @@ class MercurySmartcraft extends BTSensor{
         else
             return null
     }
+    static ImageFile = "MercurySmartcraft.jpg"