bt-sensors-plugin-sk 1.3.2 → 1.3.4-beta

package/sensor_classes/HumsienkBMS.js

@@ -0,0 +1,385 @@
+const BTSensor = require("../BTSensor");
+
+/**
+ * HSC14F Battery Management System Sensor Class
+ * 
+ * Manufacturer: BMC (HumsiENK branded)
+ * Protocol: Custom BLE protocol using AA prefix commands
+ * 
+ * Discovered protocol details:
+ * - TX Handle: 0x000c (write commands to battery)
+ * - RX Handle: 0x000e (receive notifications from battery)
+ * - Command format: aa [CMD] 00 [CMD] 00
+ * - Multi-part responses (some commands send 2-3 notifications)
+ * 
+ * Key Commands:
+ * - 0x00: Handshake
+ * - 0x21: Real-time battery data (voltage, current, SOC, temps) - PRIMARY
+ * - 0x22: Individual cell voltages
+ * - 0x23: Battery status/warnings
+ * - 0x20: Configuration data
+ * - 0x10: Manufacturer name
+ * - 0x11: Model number
+ */
+
+class HumsienkBMS extends BTSensor {
+  static Domain = BTSensor.SensorDomains.electrical;
+
+  // Discovered actual UUIDs from device
+  static TX_RX_SERVICE = "00000001-0000-1000-8000-00805f9b34fb";
+  static WRITE_CHAR_UUID = "00000002-0000-1000-8000-00805f9b34fb";
+  static NOTIFY_CHAR_UUID = "00000003-0000-1000-8000-00805f9b34fb";
+
+  static identify(device) {
+    // HSC14F batteries advertise with this service UUID
+    // Further identification would require GATT connection to read manufacturer/model
+    return null;
+  }
+
+  static ImageFile = "JBDBMS.webp"; // Using similar BMS image for now
+  static Manufacturer = "BMC (HumsiENK)";
+  static Description = "HSC14F LiFePO4 Battery Management System";
+
+  /**
+   * Create HSC14F command
+   * Format: aa [CMD] 00 [CMD] 00
+   */
+  hsc14fCommand(command) {
+    return [0xaa, command, 0x00, command, 0x00];
+  }
+
+  /**
+   * Send command to battery
+   * HSC14F requires Write Request (0x12) not Write Command (0x52)
+   */
+  async sendCommand(command) {
+    this.debug(`Sending command 0x${command.toString(16)} to ${this.getName()}`);
+    return await this.txChar.writeValue(
+      Buffer.from(this.hsc14fCommand(command))
+    );
+  }
+
+  async initSchema() {
+    super.initSchema();
+    this.addDefaultParam("batteryID");
+
+    // Number of cells parameter - configurable (default 4 for LiFePO4)
+    if (this.numberOfCells === undefined) {
+      this.numberOfCells = 4;
+    }
+
+    this.addParameter("numberOfCells", {
+      title: "Number of cells",
+      description: "Number of cells in the battery (typically 4 for 12V LiFePO4)",
+      type: "number",
+      isRequired: true,
+      default: this.numberOfCells,
+      minimum: 1,
+      maximum: 16,
+      multipleOf: 1
+    });
+
+    // Voltage
+    this.addDefaultPath("voltage", "electrical.batteries.voltage").read = (
+      buffer
+    ) => {
+      // Bytes 3-4: voltage in mV, little-endian
+      return buffer.readUInt16LE(3) / 1000;
+    };
+
+    // Current - CORRECTED based on buffer analysis
+    this.addDefaultPath("current", "electrical.batteries.current").read = (
+      buffer
+    ) => {
+      // Bytes 7-8: current in milliamps, signed little-endian
+      // Negative = charging, Positive = discharging
+      return buffer.readInt16LE(7) / 1000;
+    };
+
+    // State of Charge
+    this.addDefaultPath(
+      "SOC",
+      "electrical.batteries.capacity.stateOfCharge"
+    ).read = (buffer) => {
+      // Byte 11: SOC percentage (0-100)
+      return buffer.readUInt8(11) / 100;
+    };
+
+    // Temperature 1 (ENV temperature) - CORRECTED byte position
+    this.addMetadatum("temp1", "K", "Battery Environment Temperature", (buffer) => {
+      // Byte 27: Environment temperature in °C
+      const tempC = buffer.readUInt8(27);
+      return 273.15 + tempC; // Convert to Kelvin
+    }).default = "electrical.batteries.{batteryID}.temperature";
+
+    // Temperature 2 (MOS temperature) - CORRECTED byte position
+    this.addMetadatum("temp2", "K", "Battery MOS Temperature", (buffer) => {
+      // Byte 28: MOS (MOSFET) temperature in °C
+      const tempC = buffer.readUInt8(28);
+      return 273.15 + tempC;
+    }).default = "electrical.batteries.{batteryID}.mosfetTemperature";
+
+    // Temperature 3 (Sensor) - CORRECTED byte position
+    this.addMetadatum("temp3", "K", "Battery Sensor Temperature", (buffer) => {
+      // Byte 29: Additional temperature sensor in °C
+      const tempC = buffer.readUInt8(29);
+      return 273.15 + tempC;
+    }).default = "electrical.batteries.{batteryID}.sensorTemperature";
+
+    // Manufacturer (from command 0x10)
+    this.addMetadatum(
+      "manufacturer",
+      "",
+      "Battery Manufacturer",
+      (buffer) => {
+        // Response: aa 10 03 42 4d 43 ...
+        // ASCII bytes starting at position 3
+        const len = buffer.readUInt8(2);
+        return buffer.toString("ascii", 3, 3 + len);
+      }
+    ).default = "electrical.batteries.{batteryID}.manufacturer";
+
+    // Model (from command 0x11)
+    this.addMetadatum("model", "", "Battery Model", (buffer) => {
+      // Response: aa 11 0a 42 4d 43 2d 30 34 53 30 30 31 ...
+      const len = buffer.readUInt8(2);
+      return buffer.toString("ascii", 3, 3 + len);
+    }).default = "electrical.batteries.{batteryID}.model";
+
+    // Cell voltages (from command 0x22)
+    // Number of cells is configurable via numberOfCells parameter
+    for (let i = 0; i < this.numberOfCells; i++) {
+      this.addMetadatum(
+        `cell${i}Voltage`,
+        "V",
+        `Cell ${i + 1} voltage`,
+        (buffer) => {
+          // Cell voltages: aa 22 30 6a 0d 58 0d 8f 0d 34 0d ...
+          // Starting at byte 3, each cell is 2 bytes little-endian in mV
+          return buffer.readUInt16LE(3 + i * 2) / 1000;
+        }
+      ).default = `electrical.batteries.{batteryID}.cell${i}.voltage`;
+    }
+  }
+
+  hasGATT() {
+    return true;
+  }
+
+  usingGATT() {
+    return true;
+  }
+
+  async initGATTNotifications() {
+    // Don't use notifications for polling mode
+    // The parent class initGATTInterval will handle periodic connections
+  }
+
+  async emitGATT() {
+    try {
+      await this.getAndEmitBatteryInfo();
+    } catch (e) {
+      this.debug(`Failed to emit battery info for ${this.getName()}: ${e}`);
+      throw e; // Re-throw so parent can handle reconnection
+    }
+
+    // Get cell voltages after a short delay
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    try {
+      await this.getAndEmitCellVoltages();
+    } catch (e) {
+      this.debug(`Failed to emit cell voltages for ${this.getName()}: ${e}`);
+      throw e; // Re-throw so parent can handle reconnection
+    }
+  }
+
+  /**
+   * Get buffer response from battery command
+   * HSC14F sends multi-part responses for some commands
+   */
+  async getBuffer(command) {
+    let result = Buffer.alloc(256);
+    let offset = 0;
+    let lastPacketTime = Date.now();
+
+    // Set up listener first
+    const responsePromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        clearTimeout(timer);
+        if (completionTimer) clearTimeout(completionTimer);
+        this.rxChar.removeAllListeners("valuechanged");
+        reject(
+          new Error(
+            `Response timed out (+10s) from HSC14F device ${this.getName()}.`
+          )
+        );
+      }, 10000);
+
+      let completionTimer = null;
+
+      const valChanged = (buffer) => {
+        // HSC14F responses start with 0xaa followed by command byte
+        if (offset === 0 && (buffer[0] !== 0xaa || buffer[1] !== command)) {
+          this.debug(
+            `Invalid buffer from ${this.getName()}, expected command 0x${command.toString(
+              16
+            )}, got 0x${buffer[0].toString(16)} 0x${buffer[1].toString(16)}`
+          );
+          return;
+        }
+
+        buffer.copy(result, offset);
+        offset += buffer.length;
+        lastPacketTime = Date.now();
+
+        // Clear any existing completion timer
+        if (completionTimer) clearTimeout(completionTimer);
+
+        // Wait 200ms after last packet to consider response complete
+        // This allows multi-packet responses to assemble properly
+        completionTimer = setTimeout(() => {
+          result = Uint8Array.prototype.slice.call(result, 0, offset);
+          this.rxChar.removeAllListeners("valuechanged");
+          clearTimeout(timer);
+          resolve(result);
+        }, 200);
+      };
+
+      // Set up listener BEFORE sending command
+      this.rxChar.on("valuechanged", valChanged);
+    });
+
+    // Small delay to ensure listener is attached
+    await new Promise(r => setTimeout(r, 100));
+    
+    // Send the command
+    try {
+      await this.sendCommand(command);
+    } catch (err) {
+      this.rxChar.removeAllListeners("valuechanged");
+      throw err;
+    }
+
+    // Wait for response
+    return responsePromise;
+  }
+
+  async initGATTConnection(isReconnecting = false) {
+    await super.initGATTConnection(isReconnecting);
+    
+    // Set up GATT characteristics
+    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();
+    
+    return this;
+  }
+
+  /**
+   * Get and emit main battery data (voltage, current, SOC, temp)
+   * Uses command 0x21
+   */
+  async getAndEmitBatteryInfo() {
+    return this.getBuffer(0x21).then((buffer) => {
+      // Debug logging to verify buffer received
+      this.debug(`Command 0x21 response: ${buffer.length} bytes, hex: ${buffer.slice(0, 30).toString('hex')}`);
+      
+      ["voltage", "current", "SOC", "temp1", "temp2", "temp3"].forEach((tag) => {
+        this.emitData(tag, buffer);
+      });
+    });
+  }
+
+  /**
+   * Get and emit individual cell voltages
+   * Uses command 0x22
+   */
+  async getAndEmitCellVoltages() {
+    return this.getBuffer(0x22).then((buffer) => {
+      // Debug logging to verify buffer received
+      this.debug(`Command 0x22 response: ${buffer.length} bytes, hex: ${buffer.slice(0, 30).toString('hex')}`);
+      
+      for (let i = 0; i < this.numberOfCells; i++) {
+        this.emitData(`cell${i}Voltage`, buffer);
+      }
+    });
+  }
+
+  async initGATTInterval() {
+    // Get static info once (manufacturer, model) at first connection
+    try {
+      const mfgBuffer = await this.getBuffer(0x10);
+      this.emitData("manufacturer", mfgBuffer);
+      
+      const modelBuffer = await this.getBuffer(0x11);
+      this.emitData("model", modelBuffer);
+    } catch (e) {
+      this.debug(`Failed to get device info: ${e.message}`);
+    }
+
+    // Get first poll data before disconnecting
+    try {
+      await this.emitGATT();
+    } catch (error) {
+      this.debug(`Initial poll failed: ${error.message}`);
+    }
+
+    // Disconnect after initial data collection
+    await this.deactivateGATT().catch((e) => {
+      this.debug(`Error deactivating GATT Connection: ${e.message}`);
+    });
+    this.setState("WAITING");
+
+    // Set up polling interval - reconnect, poll, disconnect
+    this.intervalID = setInterval(async () => {
+      try {
+        this.setState("CONNECTING");
+        await this.initGATTConnection(true);
+        await this.emitGATT();
+      } catch (error) {
+        // Check if device has been removed from BlueZ cache
+        if (error.message && error.message.includes("interface not found in proxy object")) {
+          this.debug(`Device removed from BlueZ cache. Clearing stale connection state.`);
+          this.setError(`Device out of range or removed from Bluetooth cache. Waiting for rediscovery...`);
+          
+          // Clear the interval to stop futile reconnection attempts
+          if (this.intervalID) {
+            clearInterval(this.intervalID);
+            this.intervalID = null;
+          }
+          
+          // Set state to indicate waiting for rediscovery
+          this.setState("OUT_OF_RANGE");
+          return;
+        }
+        
+        this.debug(error);
+        this.setError(`Unable to emit values for device: ${error.message}`);
+      } finally {
+        await this.deactivateGATT().catch((e) => {
+          // Suppress errors when device is already removed from BlueZ
+          if (!e.message || !e.message.includes("interface not found")) {
+            this.debug(`Error deactivating GATT Connection: ${e.message}`);
+          }
+        });
+        this.setState("WAITING");
+      }
+    }, this.pollFreq * 1000);
+  }
+
+  async deactivateGATT() {
+    await this.stopGATTNotifications(this.rxChar);
+    await super.deactivateGATT();
+  }
+}
+
+module.exports = HumsienkBMS;

package/sensor_classes/JBDBMS.js

@@ -197,6 +197,7 @@ class JBDBMS extends BTSensor {
 } 
 
 async initGATTConnection() {
+  this.setConnected(await this.device.isConnected())
   return this  
 }
 

package/sensor_classes/JikongBMS.js

@@ -257,7 +257,7 @@ class JikongBMS extends BTSensor {
 
     this.addMetadatum("cycleCapacity", "number", "Cycle capacity", (buffer) => {
       return buffer.readUInt32LE(154 + this.offset * 2) / 1000;
-    }).default = "electrical.batteries.{batteryID}.discharging";
+    }).default = "electrical.batteries.{batteryID}.cycleCapacity";
 
     this.addMetadatum(
       "balanceAction",

package/sensor_classes/Renogy/RenogySensor.js

@@ -3,7 +3,7 @@ ported from https://github.com/cyrils/renogy-bt
 */
 const BTSensor = require("../../BTSensor.js");
 const VC = require('./RenogyConstants.js');
-const crc16Modbus = require('./CRC.js')
+const crc16Modbus = require('./CRC.js');
 class RenogySensor extends BTSensor{
     static Domain=BTSensor.SensorDomains.electrical
     static ALIAS_PREFIX = 'BT-TH'
@@ -34,20 +34,27 @@ class RenogySensor extends BTSensor{
         b.writeUInt16BE(words,4) 
         b.writeUInt16BE(crc16Modbus(b.subarray(0,6)),6)          
         
-        await writeCharacteristic.writeValueWithResponse(b,  0)
+        await writeCharacteristic.writeValueWithoutResponse(b,  0)
     
     }
     static identify(device){
         return null
     }
-
+    pollFreq=30
     async initSchema(){
         await super.initSchema()
-       
+        this.getGATTParams().pollFreq.default=this.pollFreq
         this.addParameter(
             "deviceID",
             {
-                title: 'ID of device'
+                title: 'ID of device',
+                description: 'only modify if device is in hub mode or daisy chained',
+                default:255,
+                type: 'number',
+                minimum: 0, 
+                maximum: 255,
+                multipleOf:1,
+                isRequired: true                
             }
         ) 
     }
@@ -73,15 +80,17 @@ class RenogySensor extends BTSensor{
     }
 
     async sendReadFunctionRequest(writeReq, words){
-        this.constructor.sendReadFunctionRequest(
+        await this.constructor.sendReadFunctionRequest(
             this.writeChar, this.getDeviceID(), writeReq, words) 
     }
 
     initGATTInterval(){
+        this.emitGATT()
         this.intervalID = setInterval(()=>{
             this.emitGATT()
         }, 1000*(this?.pollFreq??60) )
     }
+
     emitGATT(){
          this.getAllEmitterFunctions().forEach(async (emitter)=>
             await emitter()

package/sensor_classes/RenogyBattery.js

@@ -12,9 +12,21 @@ class RenogyBattery extends RenogySensor {
                 this.getAndEmitCellTemperatures.bind(this), 
                 this.getAndEmitCellVoltages.bind(this)]
     }
+    numberOfCells=4
     initSchema(){
-
-        this.addMetadatum('numberOfCells','', 'number of cells')
+        this.addDefaultParam("batteryID").default="house"
+        this.addParameter(
+            "numberOfCells",
+            {
+                title:"Number of cells",
+                type: "number",
+                isRequired: true,
+                default: this.numberOfCells,
+                minimum: 1,
+                maximum: 16,
+                multipleOf:1
+            }
+        )
         this.addDefaultPath('current','electrical.batteries.current')
             .read=(buffer)=>{return buffer.readInt16BE(3)/100}
              
@@ -41,31 +53,33 @@ class RenogyBattery extends RenogySensor {
     async initGATTConnection() {
         await super.initGATTConnection()
         this.numberOfCells = await this.retrieveNumberOfCells()
-        this.deviceID = await this.retrieveDeviceID()
-        this.emit('numberOfCells', this.numberOfCells)
     }
     
-    retrieveNumberOfCells(){
-
+    retrieveModelID(){
         return new Promise( async ( resolve, reject )=>{
-            await this.sendReadFunctionRequest(0x1388,0x11)
 
-            const valChanged = async (buffer) => {
-                resolve(buffer.readUInt16(3))
-            }
-            this.readChar.once('valuechanged', valChanged )
+        await this.sendReadFunctionRequest(0x1402,0x08)
+          
+        this.readChar.once('valuechanged', async (buffer) => {
+            if (buffer[2]!=0x10) 
+                reject("Unknown error retrieving model ID") //???
+            const model = buffer.subarray(3,17).toString().trim()
+            resolve(model)           
         })
+    })
     }
-    retrieveDeviceID(){
+    retrieveNumberOfCells(){
+
         return new Promise( async ( resolve, reject )=>{
-            this.sendFunctionRequest(0x14, 0x67)
+            await this.sendReadFunctionRequest(0x1388,0x11)
 
             const valChanged = async (buffer) => {
-                resolve((buffer.readUInt8(4)))
+                resolve(buffer.readUInt16(3))
             }
             this.readChar.once('valuechanged', valChanged )
         })
     }
+   
 
     getAndEmitBatteryInfo(){
         return new Promise( async ( resolve, reject )=>{

package/sensor_classes/RenogyInverter.js

@@ -54,10 +54,24 @@ class RenogyInverter extends RenogySensor {
         })
     }
 
+    retrieveModelID(){
+        return new Promise( async ( resolve, reject )=>{
+
+        await this.sendReadFunctionRequest(0x10d7,0x08)
+          
+        this.readChar.once('valuechanged', async (buffer) => {
+            if (buffer[2]!=0x10) 
+                reject("Unknown error retrieving model ID") //???
+            const model = buffer.subarray(3,17).toString().trim()
+            resolve(model)           
+        })
+    })
+    }
+
     getAndEmitInverterStats(){
         return new Promise( async ( resolve, reject )=>{
 
-            await this.sendReadFunctionRequest(0xfa0, 0x8)
+            await this.sendReadFunctionRequest(0xfa0, 0xA)
         
             this.readChar.once('valuechanged', (buffer) => {
                 ["ueiVoltage","ueiCurrent", "voltage", "loadCurrent", "frequency","temperature"].forEach((tag)=>
@@ -71,7 +85,7 @@ class RenogyInverter extends RenogySensor {
     getAndEmitSolarCharging(){
         return new Promise( async ( resolve, reject )=>{
 
-            await this.sendReadFunctionRequest(0x10e9, 0x5)
+            await this.sendReadFunctionRequest(0x10e9, 0x7)
         
             this.readChar.once('valuechanged', (buffer) => {
                 ["solarVoltage","solarCurrent", "solarPower", "solarChargingStatus", "solarChargingPower"].forEach((tag)=>
@@ -85,7 +99,7 @@ class RenogyInverter extends RenogySensor {
     getAndEmitInverterLoad(){
         return new Promise( async ( resolve, reject )=>{
             
-            await this.sendReadFunctionRequest(0x113a, 0x2)
+            await this.sendReadFunctionRequest(0x113a, 0x6)
         
             this.readChar.once('valuechanged', (buffer) => {
                 ["loadPower", "chargingCurrent"].forEach((tag)=>

package/sensor_classes/RenogyRoverClient.js

@@ -34,6 +34,10 @@ class RenogyRoverClient extends RenogySensor {
     initSchema(){
         //Buffer(73) [1, 3, 68, 32, 32, 82, 78, 71, 45, 67, 84, 82, 76, 45, 87, 78, 68, 51, 48, 7, 140, 0, 132, 0, 126, 0, 120, 0, 111, 0, 106, 100, 50, 0, 5, 0, 120, 0, 120, 0, 28, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 5, 0, 5, 2, 148, 0, 5, 206, 143, 34, 228, buffer: ArrayBuffer(8192), byteLength: 73, byteOffset: 6144, length: 73, Symbol(Symbol.toStringTag): 'Uint8Array']
         super.initSchema()
+
+        this.addDefaultParam("id")
+            .default="solar"
+
         this.addMetadatum('batteryType', '', "battery type")
             .default="electrical.chargers.{id}.battery.type"
         this.addMetadatum('batteryPercentage', 'ratio', "battery percentage",
@@ -118,22 +122,12 @@ class RenogyRoverClient extends RenogySensor {
 
     }
     
-    retrieveDeviceID(){
-        return new Promise( async ( resolve, reject )=>{
-            this.sendReadFunctionRequest(0x1A, 0x1)
-
-            const valChanged = async (buffer) => {
-                resolve((buffer.readUInt8(4)))
-            }
-            this.readChar.once('valuechanged', valChanged )
-        })
-    }
-
+   
     retrieveBatteryType(){
         return new Promise( async ( resolve, reject )=>{
         //Buffer(7) [255, 3, 2, 0, 1, 80, 80, buffer: ArrayBuffer(8192), byteLength: 7, byteOffset: 864, length: 7, Symbol(Symbol.toStringTag): 'Uint8Array']
 
-            this.sendReadFunctionRequest(0xe004, 0x01)
+            await this.sendReadFunctionRequest(0xe004, 0x01)
 
             const valChanged = async (buffer) => {
                 resolve(RC.BATTERY_TYPE[(buffer.readUInt8(4))])
@@ -157,13 +151,10 @@ class RenogyRoverClient extends RenogySensor {
     }
     async initGATTConnection() {
         await super.initGATTConnection()
-        if (!this.deviceID)
-            this.deviceID = await this.retrieveDeviceID()
-        this.modelID=await this.retrieveModelID()
 
+        this.modelID=await this.retrieveModelID()
         this.batteryType = await this.retrieveBatteryType()
-        this.emit('batteryType', this.batteryType)
-
+        this.emit('batteryType', this.batteryType)   
         
     }
 
@@ -175,7 +166,7 @@ class RenogyRoverClient extends RenogySensor {
     async getAndEmitChargeInfo(){
         return new Promise( async ( resolve, reject )=>{
             try {
-                this.sendReadFunctionRequest(0x100, 0x22)
+                await this.sendReadFunctionRequest(0x100, 0x22)
 
                 this.readChar.once('valuechanged', buffer => {
                     this.emitValuesFrom(buffer)

package/sensor_classes/ShenzhenLiOnBMS.js

@@ -71,11 +71,12 @@ class ShenzhenLiONBMS extends BTSensor{
          "numberOfCells",
             {
                 title:"Number of cells",
-                type: "integer",
+                type: "number",
                 isRequired: true,
                 default: 4,
                 minimum: 1,
-                maximum: 16
+                maximum: 16,
+                multipleOf:1
             }
        )
 

package/sensor_classes/VictronBatteryMonitor.js

@@ -26,7 +26,7 @@ class VictronBatteryMonitor extends VictronSensor{
         d.debug.bind(d)
         d.initSchema()
         Object.keys(d.getPaths()).forEach((tag)=>{
-                d.on(tag,(v)=>console.log(`${tag}=${v}`))
+                d.on(tag,(v)=>console.log(`${tag}=${JSON.stringify(v)}`))
         })
         if (key)
             b = d.decrypt(b)
@@ -62,7 +62,6 @@ class VictronBatteryMonitor extends VictronSensor{
         const alarmMD = this.addMetadatum('alarm','',  'alarm', 
                 (buff,offset=0)=>{return buff.readInt16LE(offset)})
                 alarmMD.default='electrical.batteries.{batteryID}.alarm'                
-                alarmMD.notify=true
 
         this.addMetadatum( 'consumed','Ah', 'amp-hours consumed', 
                 (buff,offset=0)=>{return buff.readInt32LE(offset)/10},
@@ -78,8 +77,6 @@ class VictronBatteryMonitor extends VictronSensor{
             .read=(buff,offset=0)=>{return this.NaNif(buff.readUInt16LE(offset),0xFFFF)*60}
         this.getPath("ttg").gatt='65970ffe-4bda-4c1e-af4b-551c4cf74769';
 
-        this.auxMode=VC.AuxMode.STARTER_VOLTAGE
-
         if (this.auxMode==undefined){
             const md=await this.constructor.getDataPacket(this.device, this.getManufacturerData(this.constructor.ManufacturerID))
             try {

package/sensor_classes/VictronDCEnergyMeter.js

@@ -55,7 +55,6 @@ class VictronDCEnergyMeter extends VictronSensor{
         this.addMetadatum('alarm','', 'alarm', 
             (buff)=>{return buff.readUInt16LE(4)})
            .default="electrical.meters.{id}.alarm"
-        this.getPath("alarm").notify=true
         this.addMetadatum('current','A', 'current')
         .default="electrical.meters.{id}.current"