bt-sensors-plugin-sk 1.2.6-beta-5 → 1.2.6-beta-6a

package/sensor_classes/EcoWorthyBW02.js

@@ -95,8 +95,8 @@ class EcoWorthyBW02 extends BTSensor {
         this.addDefaultPath('SOC','electrical.batteries.capacity.stateOfCharge')
         .read=(buffer)=>{return buffer.readUInt16BE(16)/100} 
   
-        await this._initGATTConnection()
-        await this._initGATTNotifications()
+        await this.initGATTConnection()
+        await this.initGATTNotifications()
         await waitForVariable(this,"numberOfTemps")
         await waitForVariable(this,"numberOfCells")
 
@@ -118,8 +118,11 @@ class EcoWorthyBW02 extends BTSensor {
   hasGATT(){
     return true
   }
+  usingGATT(){
+    return true
+  }
 
-  async _initGATTNotifications(){
+  async initGATTNotifications(){
       await this.rxChar.startNotifications()
       
       this.rxChar.on("valuechanged", (buffer)=>{
@@ -146,27 +149,17 @@ class EcoWorthyBW02 extends BTSensor {
           }
       })
   }
-async _initGATTConnection() {
-   await this.deviceConnect() 
-   const gattServer = await this.device.gatt()
+async initGATTConnection(isReconnecting) {
+   await super.initGATTConnection(isReconnecting) 
+   const gattServer = await this.getGATTServer()
    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()
-}
-  
+  async deactivateGATT(){
+      await this.stopGATTNotifications(this.rxChar)
+      await super.deactivateGATT()
+  }
 }
 module.exports = EcoWorthyBW02;

package/sensor_classes/EctiveBMS.js

@@ -35,7 +35,6 @@ const testData=[
 ]
 class EctiveDataManager extends EventEmitter{
   static expectedLength = 120
-  static ImageFile = "TopbandBattery.webp"
   buffer = Buffer.from([])
   
   delimitedAt(data){
@@ -91,6 +90,7 @@ class EctiveData{
 }
 class EctiveBMS extends BTSensor {
   static Domain = BTSensor.SensorDomains.electrical
+  static ImageFile = "TopbandBattery.webp"
 
   static RX_SERVICE = "0000ffe0-0000-1000-8000-00805f9b34fb"  
   static NOTIFY_CHAR_UUID = "0000ffe4-0000-1000-8000-00805f9b34fb"
@@ -246,23 +246,20 @@ emitGATT(){
         } )
   }
 
-  async initGATTConnection() {
+  async initGATTConnection(isReconnecting) {
      
-        await this.deviceConnect() 
-        const gattServer = await this.device.gatt()
+        await super.initGATTConnection(isReconnecting)
+        const gattServer = await this.getGATTServer()
         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()
+async deactivateGATT(){
+  await this.stopGATTNotifications(this.rxChar)
+  await super.deactivateGATT()
 }
+
   
 }
 

package/sensor_classes/GobiusCTankMeter.js

@@ -334,36 +334,23 @@ class GobiusCTankMeter extends BTSensor{
         this.getJSONSchema().properties.params.required=["type" ]
     }
 
-    initGATTConnection(){ 
-        return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
-            if (!this.gattServer) { 
-                this.gattServer = await this.device.gatt() 
-                this.service = await this.gattServer.getPrimaryService("0000ffe0-0000-1000-8000-00805f9b34fb") 
-                this.characteristic = await this.service.getCharacteristic("0000ffe9-0000-1000-8000-00805f9b34fb")
-            }
-        
-  
-            resolve(this)
-            }).catch((e)=>{ reject(e.message) }) }) 
-
+    async initGATTConnection(isReconnecting){
+        await super.initGATTConnection(isReconnecting) 
+        const gattServer = await this.getGATTServer() 
+        const service = await gattServer.getPrimaryService("0000ffe0-0000-1000-8000-00805f9b34fb") 
+        this.characteristic = await service.getCharacteristic("0000ffe9-0000-1000-8000-00805f9b34fb")
     }
-    initGATTNotifications() { 
-        Promise.resolve(this.characteristic.startNotifications().then(()=>{    
-            this.characteristic.on('valuechanged', buffer => {
+    async initGATTNotifications() { 
+        await this.characteristic.startNotifications()
+        this.characteristic.on('valuechanged', buffer => {
                 this.emitValuesFrom(buffer)
-            })
-        }))
+        })
     }
 
-    async stopListening(){
-        super.stopListening()
-        if (this.characteristic  && await this.characteristic.isNotifying()) {
-            await this.characteristic.stopNotifications()
-            this.characteristic=null
-        }
-        if (await this.device.isConnected()){
-            await this.device.disconnect()
-        }
+    async deactivateGATT(){
+        await this.stopNotifications(this.characteristic)
+        await super.deactivateGATT()
     }
+   
 }
 module.exports=GobiusCTankMeter

package/sensor_classes/JBDBMS.js

@@ -107,7 +107,7 @@ class JBDBMS extends BTSensor {
   usingGATT(){
     return true
   }
-  initGATTNotifications(){
+  async initGATTNotifications(){
     this.intervalID = setInterval( async ()=>{
         await this.emitGATT()
     }, 1000*(this?.pollFreq??60) )
@@ -198,18 +198,15 @@ async getAndEmitCellVoltages(){
   }})
 }
 
-initGATTInterval(){
+async initGATTInterval(){
    
-  this.emitGATT()
-  this.initGATTNotifications()
+  await this.emitGATT()
+  await this.initGATTNotifications()
 }
 
-async stopListening(){
-  super.stopListening()
-  if (this.rxChar) 
-    this.rxChar.stopNotifications()
-  if (this.device)
-    await this.device.disconnect()
+async deactivateGATT(){
+  await this.stopGATTNotifications(this.rxChar)
+  await super.deactivateGATT()
 }
   
 }

package/sensor_classes/JikongBMS.js

@@ -69,6 +69,7 @@ class JikongBMS extends BTSensor {
   }
   static ImageFile = "JikongBMS.jpg";
   connections = 0;
+  pollFreq = 30;
 
   jikongCommand(command) {
     var result = [
@@ -109,7 +110,7 @@ class JikongBMS extends BTSensor {
     }
   }
 
-  pollFreq=20
+  
   async initSchema() {
     super.initSchema();
     this.addDefaultParam("batteryID");
@@ -131,6 +132,7 @@ class JikongBMS extends BTSensor {
 
     if (this.numberOfCells == undefined) {
       try {
+        this.debug("Getting number of cells...")
         await this.initGATTConnection();
         this.numberOfCells = await this.getNumberOfCells()
       }
@@ -315,9 +317,9 @@ class JikongBMS extends BTSensor {
       }
     ).default = "electrical.batteries.{batteryID}.discharging";
 
-    this.addMetadatum("temp1", "K", "Temperature 1 in K", (buffer) => {
+    this.addMetadatum("temp1", "K", "Temperature in K", (buffer) => {
       return 273.15 + buffer.readInt16LE(130 + this.offset * 2) / 10;
-    }).default = "electrical.batteries.{batteryID}.temperature1";
+    }).default = "electrical.batteries.{batteryID}.temperature";
 
     this.addMetadatum("temp2", "K", "Temperature 2 in K", (buffer) => {
       return 273.15 + buffer.readInt16LE(132 + this.offset * 2) / 10;
@@ -403,7 +405,7 @@ class JikongBMS extends BTSensor {
   }
 
   usingGATT() {
-    return false;
+    return true;
   }
 
   async getAndEmitBatteryInfo() {
@@ -437,70 +439,63 @@ class JikongBMS extends BTSensor {
   }
 
   async deactivateGATT() {
-    this.debug(`${this.getName()}::deactivateGATT`);
-    if (this.rxChar) {
-      try {
-        await this.rxChar.stopNotifications();
-      } catch (e) {
-        this.debug(
-          `(${this.getName()}) Error stopping notifications for rxChar`
-        );
-      }
-    }
+    await this.stopGATTNotifications(this.rxChar) 
+
     await super.deactivateGATT();
   }
 
   async initGATTConnection(isReconnecting = false) {
     this.debug(`${this.getName()}::initGATTConnection`);
 
-    await super.initGATTConnection(isReconnecting);
-    const gattServer = await this.getGATTServer();
-
-    this.rxService = await gattServer.getPrimaryService(
-      this.constructor.RX_SERVICE
-    );
-    
     if (this.rxChar)
       try {
+        this.rxChar.removeAllListeners()
         await this.rxChar.stopNotifications()
       }
       catch(e){
-        this.rxChar.removeAllListeners()
-
         this.debug(`error while stopping notifications`)
         this.debug(e)
       }
+    
+    try {
+      await super.initGATTConnection(isReconnecting);
+      const gattServer = await this.getGATTServer();
 
-    this.rxChar = await this.rxService.getCharacteristic(
-      this.constructor.RX_CHAR_UUID
-    );
+      this.rxService = await gattServer.getPrimaryService(
+        this.constructor.RX_SERVICE
+      );
+      this.rxChar = await this.rxService.getCharacteristic(
+        this.constructor.RX_CHAR_UUID
+      );
+      await this.rxChar.startNotifications();
 
-    await this.rxChar.startNotifications();
-    try {
-      await this.getBuffer(0x97)
     } catch (e) {
       this.setError(e.message)
     }
-
+    
+    try {
+      await this.getBuffer(0x97)
+    } catch(e){
+      this.debug(`Error encountered calling getBuffer(0x97)`)
+    }
     //this.debug(`(${this.getName()}) Connections: ${this.connections++}`)
   }
 
-  activate(config, plugin) {
-    super.activate(config, plugin);
-    this.initGATTConnection().then(async () => {
-      try {
-        await this.getAndEmitBatteryInfo();
-      } catch(e) {
-        this.setError(e.message)
-      }
-      this.intervalID = setInterval(async () => {
+  async initGATTInterval(){
+    this.intervalID = setInterval(async () => {
+        this._error = false
         if (!(await this.device.isConnected())) {
           await this.initGATTConnection(true);
         }
         await this.getAndEmitBatteryInfo();
-      }, this.pollFreq * 1000);
-    });
-  }
+      }, (this?.pollFreq??40) * 1000);
+
+    try {
+      await this.getAndEmitBatteryInfo();
+    } catch(e) {
+      this.setError(e.message)
+    } 
+    }
 }
 
 module.exports = JikongBMS;

package/sensor_classes/Junctek.js

@@ -151,35 +151,24 @@ class JunctekBMS extends BTSensor{
             this.emitFrom(buffer)
         })*/
     }
-    initGATTConnection(){ 
-        return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
-            if (!this.gattServer) { 
-                this.gattServer = await this.device.gatt() 
-                this.battService = await this.gattServer.getPrimaryService("0000fff0-0000-1000-8000-00805f9b34fb") 
-                this.battCharacteristic = await this.battService.getCharacteristic("0000fff1-0000-1000-8000-00805f9b34fb")
+    async initGATTConnection(isReconnecting){ 
+        super.initGATTConnection(isReconnecting)
+            const gattServer = await this.getGATTServer()
+            const battService = await gattServer.getPrimaryService("0000fff0-0000-1000-8000-00805f9b34fb") 
+            this.battCharacteristic = await battService.getCharacteristic("0000fff1-0000-1000-8000-00805f9b34fb")
 
-            }
-                resolve(this)
-             }) .catch((e)=>{ reject(e.message) }) }) 
     }
 
-    initGATTNotifications() { 
-        Promise.resolve(this.battCharacteristic.startNotifications().then(()=>{    
-            this.battCharacteristic.on('valuechanged', buffer => {
+    async initGATTNotifications() { 
+        this.battCharacteristic.startNotifications()
+        this.battCharacteristic.on('valuechanged', buffer => {
                 this.emitFrom(buffer)
-            })
-        }))
+        })
+        
     }
-  
-    async stopListening(){
-        super.stopListening()
-        if (this.battCharacteristic  && await this.battCharacteristic.isNotifying()) {
-            await this.battCharacteristic.stopNotifications()
-            this.battCharacteristic=null
-        }
-        if (await this.device.isConnected()){
-            await this.device.disconnect()
-        }
+    async deactivateGATT(){
+        await this.stopGATTNotifications(this.battCharacteristic) 
+        await super.deactivateGATT()
     }
 }
 module.exports=JunctekBMS

package/sensor_classes/KilovaultHLXPlus.js

@@ -194,34 +194,25 @@ class KilovaultHLXPlus extends BTSensor{
       }
     }
 
-    initGATTConnection(){ 
-        return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
-            if (!this.gattServer) { 
-                this.gattServer = await this.device.gatt() 
-                this.battService = await this.gattServer.getPrimaryService("0000ffe0-0000-1000-8000-00805f9b34fb") 
-                this.battCharacteristic = await this.battService.getCharacteristic("0000ffe4-0000-1000-8000-00805f9b34fb")
-                }
-                resolve(this)
-             }) .catch((e)=>{ reject(e.message) }) }) 
+    async initGATTConnection(isReconnecting){ 
+        await super.initGATTConnection(isReconnecting)
+        const gattServer= this.getGATTServer()
+        
+        this.battService = await gattServer.getPrimaryService("0000ffe0-0000-1000-8000-00805f9b34fb") 
+        this.battCharacteristic = await battService.getCharacteristic("0000ffe4-0000-1000-8000-00805f9b34fb")
     }
 
-    initGATTNotifications() { 
-        Promise.resolve(this.battCharacteristic.startNotifications().then(()=>{    
-            this.battCharacteristic.on('valuechanged', buffer => {
-                this.reassemble(buffer)
-            })
-        }))
+    async initGATTNotifications() { 
+        await this.battCharacteristic.startNotifications()
+        this.battCharacteristic.on('valuechanged', buffer => {
+            this.reassemble(buffer)
+        })
+
     }
-  
-    async stopListening(){
-        super.stopListening()
-        if (this.battCharacteristic  && await this.battCharacteristic.isNotifying()) {
-            await this.battCharacteristic.stopNotifications()
-            this.battCharacteristic=null
-        }
-        if (await this.device.isConnected()){
-               await this.device.disconnect()
-        }
+    async deactivateGATT(){
+        await this.stopGATTNotifications(this.battCharacteristic)
+        await super.deactivateGATT()
     }
+  
 }
 module.exports=KilovaultHLXPlus

package/sensor_classes/MercurySmartcraft.js

@@ -28,10 +28,8 @@ class MercurySmartcraft extends BTSensor{
     }
     static ImageFile = "MercurySmartcraft.jpg"
 
-    
-
     hasGATT(){
-        return false
+        return true
     }
     usingGATT(){
         return true
@@ -80,48 +78,40 @@ class MercurySmartcraft extends BTSensor{
         ).default='tanks.petrol.currentLevel'
     }
 
-    initGATTConnection(){ 
-        return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
-            if (!this.gattServer) { 
-                this.gattServer = await this.device.gatt() 
-                this.sdpService = await this.gattServer.getPrimaryService("00000000-0000-1000-8000-ec55f9f5b963") 
-                this.sdpCharacteristic = await this.sdpService.getCharacteristic("00000001-0000-1000-8000-ec55f9f5b963") 
-                this.dataService = await this.gattServer.getPrimaryService("00000100-0000-1000-8000-ec55f9f5b963") 
-                this.dataCharacteristics = {
-                    rpm: await this.dataService.getCharacteristic("00000102-0000-1000-8000-ec55f9f5b963"),
-                    coolant: await this.dataService.getCharacteristic("00000103-0000-1000-8000-ec55f9f5b963"),
-                    alternatorVoltage: await this.dataService.getCharacteristic("00000104-0000-1000-8000-ec55f9f5b963"),
-                    runtime: await this.dataService.getCharacteristic("00000106-0000-1000-8000-ec55f9f5b963"),
-                    rate: await this.dataService.getCharacteristic("00000107-0000-1000-8000-ec55f9f5b963"),
-                    level: await this.dataService.getCharacteristic("00000108-0000-1000-8000-ec55f9f5b963"),
-                    pressure: await this.dataService.getCharacteristic("0000010a-0000-1000-8000-ec55f9f5b963")
-                }
-            } 
-                resolve(this)
-             }) .catch((e)=>{ reject(e.message) }) }) 
+    async initGATTConnection(isReconnecting){ 
+        await super.initGATTConnection(isReconnecting)
+        
+        const gattServer = await this.getGATTServer() 
+        this.sdpService = await gattServer.getPrimaryService("00000000-0000-1000-8000-ec55f9f5b963") 
+        this.sdpCharacteristic = await this.sdpService.getCharacteristic("00000001-0000-1000-8000-ec55f9f5b963") 
+        this.dataService = await gattServer.getPrimaryService("00000100-0000-1000-8000-ec55f9f5b963") 
+        this.dataCharacteristics = {
+            rpm: await this.dataService.getCharacteristic("00000102-0000-1000-8000-ec55f9f5b963"),
+            coolant: await this.dataService.getCharacteristic("00000103-0000-1000-8000-ec55f9f5b963"),
+            alternatorVoltage: await this.dataService.getCharacteristic("00000104-0000-1000-8000-ec55f9f5b963"),
+            runtime: await this.dataService.getCharacteristic("00000106-0000-1000-8000-ec55f9f5b963"),
+            rate: await this.dataService.getCharacteristic("00000107-0000-1000-8000-ec55f9f5b963"),
+            level: await this.dataService.getCharacteristic("00000108-0000-1000-8000-ec55f9f5b963"),
+            pressure: await this.dataService.getCharacteristic("0000010a-0000-1000-8000-ec55f9f5b963")
+        }
+
     }
     async initGATTNotifications() { 
         await this.sdpCharacteristic.writeValue(Buffer.from([0x0D,0x01]))
         for (const c in this.dataCharacteristics){
-            Promise.resolve(this.dataCharacteristics[c].startNotifications().then(()=>{    
-                this.dataCharacteristics[c].on('valuechanged', buffer => {
-                    this.emitData(c,buffer)
-                })
-            }))
+            await this.dataCharacteristics[c].startNotifications()
+            this.dataCharacteristics[c].on('valuechanged', buffer => {
+                this.emitData(c,buffer)
+            })
         }
     }
-  
-    async stopListening(){
-        super.stopListening()
+    async deactivateGATT(){
         for (const c in this.dataCharacteristics){
-            if (this.dataCharacteristics[c] && await this.dataCharacteristics[c].isNotifying()) {
-                await this.dataCharacteristics[c].stopNotifications()
-            }
+            await this.stopGATTNotifications(c)
         }
+        await super.deactivateGATT()
 
-        if (await this.device.isConnected()){
-            await this.device.disconnect()
-        }
     }
+
 }
 module.exports=MercurySmartcraft

package/sensor_classes/MopekaTankSensor.js

@@ -90,7 +90,7 @@ class MopekaTankSensor extends BTSensor{
         this.addParameter("tankHeight",
             {
                 title:"height of tank (in mm)",
-                type:"integer",
+                type:"number",
                 unit:"mm",
                 isRequired: true
             }

package/sensor_classes/RemoranWave3.js

@@ -177,49 +177,41 @@ const BTSensor = require("../BTSensor");
     }
 
  
-     initGATTConnection(){ 
-         return new Promise((resolve,reject )=>{ this.deviceConnect().then(async ()=>{ 
-             if (!this.gattServer) { 
-                 this.gattServer = await this.device.gatt() 
-                 this.service = await this.gattServer.getPrimaryService(this.serviceUUID) 
-                 this.info1Characteristic = await this.service.getCharacteristic(this.info1CharUUID)
-                 this.info2Characteristic = await this.service.getCharacteristic(this.info2CharUUID) 
-                 this.eventCharacteristic = await this.service.getCharacteristic(this.eventUUID)
-                 resolve(this)
-            }}) .catch((e)=>{ this.debug(e); reject(e.message) }) }) 
+     async initGATTConnection(isReconnecting){ 
+        await super.initGATTConnection(isReconnecting)
+        const gattServer = await this.getGATTServer()
+        const service = await gattServer.getPrimaryService(this.serviceUUID) 
+        this.info1Characteristic = await service.getCharacteristic(this.info1CharUUID)
+        this.info2Characteristic = await service.getCharacteristic(this.info2CharUUID) 
+        this.eventCharacteristic = await service.getCharacteristic(this.eventUUID)
      }
      
-     initGATTNotifications() { 
-         Promise.resolve(this.info1Characteristic.startNotifications().then(()=>{    
+     async initGATTNotifications() { 
+         await this.info1Characteristic.startNotifications()
              this.info1Characteristic.on('valuechanged', buffer => {
                  this.emitInfo1Data(buffer)
              })
-         }))
-         Promise.resolve(this.info2Characteristic.startNotifications().then(()=>{    
-             this.info2Characteristic.on('valuechanged', buffer => {
+         
+        await this.info2Characteristic.startNotifications()
+            this.info2Characteristic.on('valuechanged', buffer => {
                  this.emitInfo2Data(buffer)
              })
-         }))
-         Promise.resolve(this.eventCharacteristic.startNotifications().then(()=>{    
+         
+        await this.eventCharacteristic.startNotifications()
              this.eventCharacteristic.on('valuechanged', buffer => {
                  this.emitEventData(buffer)
              })
-         }))
+         
      }
     
-    async stopNotifications(characteristic){
-        if (characteristic  && await characteristic.isNotifying()) {
-                await characteristic.stopNotifications()
-        }
-    }
-     async stopListening(){
-        super.stopListening()
-        await this.stopNotifications(this?.info1Characteristic)
-        await this.stopNotifications(this?.info2Characteristic)
-        await this.stopNotifications(this?.eventCharacteristic)
-        if (await this.device.isConnected()){
-            await this.device.disconnect()
-        }
+   
+     async deactivateGATT(){
+        
+        await this.stopGATTNotifications(this?.info1Characteristic)
+        await this.stopGATTNotifications(this?.info2Characteristic)
+        await this.stopGATTNotifications(this?.eventCharacteristic)
+        await super.deactivateGATT()
+ 
      }
  }
  module.exports=RemoranWave3

package/sensor_classes/Renogy/RenogySensor.js

@@ -92,8 +92,8 @@ class RenogySensor extends BTSensor{
  
     }
 
-    async initGATTConnection() {   
-        await this.deviceConnect()      
+    async initGATTConnection(isReconnecting) {   
+        await super.initGATTConnection(isReconnecting)
         const rw = await this.constructor.getReadWriteCharacteristics(this.device)
 
         this.readChar = rw.read    
@@ -108,18 +108,11 @@ class RenogySensor extends BTSensor{
     hasGATT(){
         return true
     }
-
-    async stopListening(){
-        super.stopListening()
-    
-        if (this.readChar)
-            await this.readChar.stopNotifications()
-        
-        if (await this.device.isConnected()){
-            await this.device.disconnect()
-            this.debug(`Disconnected from ${ this.getName()}`)
-        }
+    async deactivateGATT(){
+        await this.stopGATTNotifications(this.readChar)
+        await super.deactivateGATT()
     }
 
+
 }
 module.exports=RenogySensor