bt-sensors-plugin-sk 1.3.8-beta2 → 1.3.8-beta4

package/BTSensor.js

@@ -613,6 +613,7 @@ class BTSensor extends EventEmitter {
             ) 
             try {
                 await this.device.helper.callMethod('Connect')
+                await new Promise(resolve => setTimeout(resolve, 2000));
             } catch (e) {
                 this.debug(e)
                 throw new Error(e.message)
@@ -1184,7 +1185,7 @@ class BTSensor extends EventEmitter {
                             path: `notifications.sensors.${this.macAndName()}`,
                             value: {
                             state: "warn",
-                            message: "Unable to communicate with sensor",
+                            message: `Unable to communicate with BT sensor: ${this.macAndName()}` ,
                             method: ["visual", "sound"]
                         }
                         }]
@@ -1219,7 +1220,7 @@ class BTSensor extends EventEmitter {
                             path: `notifications.sensors.${this.macAndName()}`,
                             value: {
                             state: "warn",
-                            message: `No contact with sensor for ${this.elapsedTimeSinceLastContact()} seconds`,
+                            message: `No contact with BT sensor ${this.macAndName()} for ${this.elapsedTimeSinceLastContact()} seconds`,
                             method: ["visual", "sound"]
                         }
                         }]
@@ -1238,7 +1239,7 @@ class BTSensor extends EventEmitter {
                             path: `notifications.sensors.${this.macAndName()}`,
                             value: {
                             state: "normal",
-                            message: `Communication with sensor normal`,
+                            message: `Normal communication with BT sensor ${this.macAndName()}`,
                             method: []
                         }
                         }]

package/README.md

@@ -1,9 +1,16 @@
 # Bluetooth Sensors for [Signal K](http://www.signalk.org) 
 
 ## WHAT'S NEW  
-# Version 1.3.8-beta2
+# Version 1.3.8-beta2/3/4
+- SensorPush fixes 
+- Error/state code and description for Victron devices per issue #124
+- More descriptive notifications per issue #126
+- V19 Jikong BMS support 
+
+## New sensors
+
+- Shelly/Ecowitt WS90 weather station
 
-- SensorPush fixes
 
 # Version 1.3.8-beta1
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bt-sensors-plugin-sk",
-  "version": "1.3.8-beta2",
+  "version": "1.3.8-beta4",
   "description": "Bluetooth Sensors for Signalk - see https://www.npmjs.com/package/bt-sensors-plugin-sk#supported-sensors for a list of supported sensors",
   "main": "index.js",
   "dependencies": {

package/sensor_classes/JikongBMS.js

@@ -31,8 +31,8 @@ class JikongBMS extends BTSensor {
   static validAcknowledgeHeader = 0xaa5590eb;
 
   static commandResponse = {
-    0x96: 0x02,
-    0x97: 0x03,
+    0x96: [0x02],
+    0x97: [0x01, 0x03],
   };
 
   static async test(datafile) {
@@ -350,57 +350,150 @@ class JikongBMS extends BTSensor {
 
   getBuffer(command) {
     return new Promise(async (resolve, reject) => {
-      const r = await this.sendReadFunctionRequest(command);
-      let datasize = 300;
-      let result = Buffer.alloc(datasize);
-      let offset = 0;
+      const datasize = 300;
+      const expectedResponses = []
+        .concat(this.constructor.commandResponse[command] ?? [])
+        .filter((frameType) => frameType !== undefined);
+      let stream = Buffer.alloc(0);
+      let timer;
+      let settled = false;
+
+      const removeValueChangedListener = () => {
+        if (typeof this.rxChar?.off === "function") {
+          this.rxChar.off("valuechanged", valChanged);
+        } else if (typeof this.rxChar?.removeListener === "function") {
+          this.rxChar.removeListener("valuechanged", valChanged);
+        }
+      };
 
-      const timer = setTimeout(() => {
-        this.rxChar.removeAllListeners();
+      const cleanup = () => {
+        removeValueChangedListener();
         clearTimeout(timer);
-        reject(
-          new Error(
-            `Response timed out (+30s) getting results for command ${command} from JikongBMS device ${this.getName()}.`
-          )
-        );
-      }, 30000);
+      };
 
-      const valChanged = async (buffer) => {
-        if (
-          offset == 0 && //first packet
-          (buffer.length < 5 ||
-            buffer.readUInt32BE(0) !== this.constructor.validResponseHeader)
-        ) {
-          if (
-            buffer.readUInt32BE(0) !== this.constructor.validAcknowledgeHeader
-          )
+      const resolveBuffer = (buffer) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(buffer);
+      };
+
+      const rejectBuffer = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      const findHeader = (buffer, start = 0) => {
+        for (let i = start; i <= buffer.length - 4; i++) {
+          const header = buffer.readUInt32BE(i);
+          if (header === this.constructor.validResponseHeader) {
+            return { index: i, header };
+          }
+          if (header === this.constructor.validAcknowledgeHeader) {
+            return { index: i, header };
+          }
+        }
+        return null;
+      };
+
+      const parseStream = () => {
+        while (stream.length >= 4) {
+          const headerMatch = findHeader(stream);
+
+          if (!headerMatch) {
+            // Preserve a possible partial 4-byte header between notifications.
+            stream = stream.slice(-3);
+            return;
+          }
+
+          if (headerMatch.index > 0) {
             this.debug(
-              `Invalid buffer ${JSON.stringify(
-                buffer
-              )}from ${this.getName()}, not processing.`
+              `Discarding ${headerMatch.index} leading byte(s) before JK header for ${this.getName()}`
             );
-        } else {
-          buffer.copy(result, offset);
-          if (offset + buffer.length == datasize) {
-            if (result[4] == this.constructor.commandResponse[command]) {
-              this.rxChar.removeAllListeners();
-              clearTimeout(timer);
-              this.debug(
-                `Rec'd command in buffer ${JSON.stringify(
-                  result
-                )} for ${this.getName()}`
-              );
-              resolve(result);
-            } else {
-              offset = 0;
-              result = Buffer.alloc(datasize);
+            stream = stream.slice(headerMatch.index);
+          }
+
+          if (
+            stream.length >= 4 &&
+            stream.readUInt32BE(0) === this.constructor.validAcknowledgeHeader
+          ) {
+            // Old/new JK modules often append a short ack after the data frame.
+            if (stream.length <= 4) {
+              return;
             }
-          } else {
-            offset += buffer.length;
+            stream = stream.slice(4);
+            continue;
+          }
+
+          if (stream.length < datasize) {
+            return;
+          }
+
+          const candidate = stream.slice(0, datasize);
+          const computedCRC =
+            sumByteArray(candidate.subarray(0, datasize - 1)) & 0xff;
+          const remoteCRC = candidate[datasize - 1];
+
+          if (computedCRC !== remoteCRC) {
+            const nextHeader = findHeader(stream, 1);
+            const bytesToDrop = nextHeader ? nextHeader.index : 1;
+            this.debug(
+              `CRC mismatch for ${this.getName()} (${computedCRC} != ${remoteCRC}), dropping ${bytesToDrop} byte(s)`
+            );
+            stream = stream.slice(bytesToDrop);
+            continue;
+          }
+
+          if (
+            expectedResponses.length === 0 ||
+            expectedResponses.includes(candidate[4])
+          ) {
+            this.debug(
+              `Rec'd command in buffer ${JSON.stringify(
+                candidate
+              )} for ${this.getName()}`
+            );
+            resolveBuffer(candidate);
+            return;
           }
+
+          this.debug(
+            `Ignoring JK frame type ${candidate[4]} while waiting for ${expectedResponses.join(
+              ", "
+            )} from ${this.getName()}`
+          );
+          stream = stream.slice(datasize);
         }
       };
+
+      const valChanged = async (buffer) => {
+        if (settled) {
+          return;
+        }
+        if (!Buffer.isBuffer(buffer)) {
+          buffer = Buffer.from(buffer);
+        }
+        stream = Buffer.concat([stream, buffer]);
+        parseStream();
+      };
+
+      timer = setTimeout(() => {
+        rejectBuffer(
+          new Error(
+            `Response timed out (+30s) getting results for command ${command} from JikongBMS device ${this.getName()}.`
+          )
+        );
+      }, 30000);
+
+      // Listen before writing so the first JK notification chunk is not lost.
       this.rxChar.on("valuechanged", valChanged);
+      await this.sendReadFunctionRequest(command);
     });
   }
 

package/sensor_classes/SensorPush.js

@@ -16,6 +16,7 @@ class SensorPush extends BTSensor{
     static ServiceUUID = "EF090000-11D6-42BA-93B8-9DD7EC090AB0"
     static Characteristics = 
         {
+
             tx:   "EF090003-11D6-42BA-93B8-9DD7EC090AA9",
             adv:  "EF090005-11D6-42BA-93B8-9DD7EC090AA9",
             batt: "EF090007-11D6-42BA-93B8-9DD7EC090AA9",
@@ -32,16 +33,25 @@ class SensorPush extends BTSensor{
     }
     
     async emitGATT(){
+        await this.characteristics.temp.writeValue(Buffer.from([1,0,0,0]))
+
         this.emitData("temp", await this.characteristics.temp.readValue())
+        
+        await this.characteristics.hum.writeValue(Buffer.from([1,0,0,0]))
         this.emitData("humidity", await this.characteristics.hum.readValue())
+        
         this.emitData("batt", await this.characteristics.batt.readValue())
-        this.emitData("pressure", await this.characteristics.bar.readValue())
+        
+        if (this.characteristics.bar){
+            await this.characteristics.bar.writeValue(Buffer.from([1,0,0,0]))
+            this.emitData("pressure", await this.characteristics.bar.readValue())
+        }
     }
 
      initSchema(){
         super.initSchema()
         this.getGATTParams()["useGATT"].default=true
-        this.getGATTParams()["pollFreq"].default=30
+        this.getGATTParams()["pollFreq"].default=60
         this._schema.properties.gattParams.required.push("pollFreq")
         
         this.addDefaultParam("zone")
@@ -84,7 +94,7 @@ class SensorPush extends BTSensor{
         .read=(buffer)=>{ return buffer.readUInt16LE()/1000}
 
         this.addDefaultPath("temp","environment.temperature") 
-        .read=(buffer)=>{ return buffer.readInt32LE()/100}
+        .read=(buffer)=>{ return 273.15+(buffer.readInt32LE()/100)}
        
         this.addDefaultPath("humidity","environment.humidity") 
         .read=(buffer)=>{ return buffer.readInt32LE()/10000}
@@ -118,13 +128,20 @@ class SensorPush extends BTSensor{
         const service = await gattServer.getPrimaryService(this.constructor.ServiceUUID.toLowerCase()) 
         this.characteristics={}
         for (const c in this.constructor.Characteristics) {
-            this.characteristics[c] = await service.getCharacteristic(this.constructor.Characteristics[c].toLowerCase())
+            const uuid = this.constructor.Characteristics[c].toLowerCase()
+            try{
+                this.characteristics[c] = await service.getCharacteristic(uuid)
+            } catch (e) {
+                this.debug(`characteristic ${c} with uuid ${uuid} not available.`)
+            }
         }
-        if (this.tx) 
+        if (this.tx && this.characteristics.tx) 
             await writeInt8(this.characteristics.tx,this.tx)
-        if (this.LED) 
+        
+        if (this.LED && this.characteristics.LED) 
             await writeUInt8(this.characteristics.LED,this.LED)
-        if (this.adv) 
+        
+        if (this.adv && this.characteristics.adv) 
             await writeUInt16LE(this.characteristics.adv,Math.round((this.adv/625)*1000))
     }
     async initGATTNotifications() { 

package/sensor_classes/ShellySBWS90CM.js

@@ -0,0 +1,231 @@
+const AbstractBTHomeSensor = require("./BTHome/AbstractBTHomeSensor");
+
+/**
+ * Sensor class representing the Shelly / Ecowitt WS90 weather station.
+ * The device publishes BTHome v2 service data on UUID 0xFCD2.
+ */
+class ShellySBWS90CM extends AbstractBTHomeSensor {
+  static Domain = this.SensorDomains.environmental;
+  static SHORTENED_LOCAL_NAME = "SBWS-90CM";
+  static LOCAL_NAME = "SBWS-90CM";
+  static ImageFile = "shelly-ws90.jpeg";
+
+  getTextDescription() {
+    return `Shelly/Ecowitt WS90 weather station (BTHome v2 over BLE service UUID 0xFCD2).`;
+  }
+
+  getId() {
+    // Stable, persistent ID so SignalK can store configuration
+    return `ShellySBWS90CM:${this.getAddress()}`;
+  }
+
+  initSchema() {
+    super.initSchema();
+    this.addDefaultParam("zone", true).default = "outside";
+
+    this.addMetadatum("temperatureK", "K", "outside temperature", this.parseTemperatureK.bind(this)).default =
+      "environment.{zone}.temperature";
+
+    this.addMetadatum("humidityRatio", "ratio", "relative humidity", this.parseHumidityRatio.bind(this)).default =
+      "environment.{zone}.humidity";
+
+    this.addMetadatum("pressurePa", "Pa", "ambient pressure", this.parsePressurePa.bind(this)).default =
+      "environment.outside.pressure";
+
+    this.addMetadatum("illuminanceLux", "lux", "illuminance", this.parseIlluminanceLux.bind(this)).default =
+      "environment.{zone}.illuminance";
+
+    this.addMetadatum("uvIndex", "", "UV index", this.parseUVIndex.bind(this)).default = "environment.{zone}.uvIndex";
+
+    this.addMetadatum("isRaining", "boolean", "rain status", this.parseIsRaining.bind(this)).default =
+      "environment.{zone}.raining";
+
+    this.addMetadatum("precipitationMm", "mm", "precipitation", this.parsePrecipitationMm.bind(this)).default =
+      "environment.{zone}.precipitation";
+
+    this.addMetadatum("windSpeed", "m/s", "true wind speed", this.parseWindSpeed.bind(this)).default = "environment.wind.speedTrue";
+
+    this.addMetadatum("windGust", "m/s", "true wind gust", this.parseWindGust.bind(this)).default = "environment.wind.gust";
+
+    this.addMetadatum("windDirectionRad", "rad", "true wind direction", this.parseWindDirectionRad.bind(this)).default =
+      "environment.wind.directionTrue";
+
+    this.addMetadatum("batteryRatio", "ratio", "battery ratio", this.parseBatteryRatio.bind(this)).default =
+      "sensors.{macAndName}.battery";
+  }
+
+  parseBatteryRatio(decoded) {
+    if (typeof decoded.batteryRatio === "number") return decoded.batteryRatio;
+    return null;
+  }
+
+  parseTemperatureK(decoded) {
+    if (typeof decoded.temperatureK === "number") return decoded.temperatureK;
+    return null;
+  }
+
+  parseHumidityRatio(decoded) {
+    if (typeof decoded.humidityRatio === "number") return decoded.humidityRatio;
+    return null;
+  }
+
+  parsePressurePa(decoded) {
+    if (typeof decoded.pressurePa === "number") return decoded.pressurePa;
+    return null;
+  }
+
+  parseIlluminanceLux(decoded) {
+    if (typeof decoded.illuminanceLux === "number") return decoded.illuminanceLux;
+    return null;
+  }
+
+  parseUVIndex(decoded) {
+    if (typeof decoded.uvIndex === "number") return decoded.uvIndex;
+    return null;
+  }
+
+  parseIsRaining(decoded) {
+    if (typeof decoded.isRaining === "boolean") return decoded.isRaining;
+    return null;
+  }
+
+  parsePrecipitationMm(decoded) {
+    if (typeof decoded.precipitationMm === "number") return decoded.precipitationMm;
+    return null;
+  }
+
+  parseWindDirectionRad(decoded) {
+    if (typeof decoded.windDirectionRad === "number") return decoded.windDirectionRad;
+    return null;
+  }
+
+  parseWindSpeed(decoded) {
+    if (typeof decoded.windSpeed === "number") return decoded.windSpeed;
+    return null;
+  }
+
+  parseWindGust(decoded) {
+    if (typeof decoded.windGust === "number") return decoded.windGust;
+    return null;
+  }
+
+  readU16LE(buffer, index) {
+    return buffer.readUInt16LE(index);
+  }
+
+  readI16LE(buffer, index) {
+    return buffer.readInt16LE(index);
+  }
+
+  readU24LE(buffer, index) {
+    return buffer[index] | (buffer[index + 1] << 8) | (buffer[index + 2] << 16);
+  }
+
+  decodeWS90BTHomeData(buffer) {
+    if (!buffer || buffer.length < 1) return null;
+
+    const decoded = {};
+    const deviceInfo = buffer.readUInt8(0);
+    // BTHome v2 encryption flag: bit0 = 1 means encrypted payload
+    if ((deviceInfo & 0x01) !== 0) {
+      this.debug(`${this.getDisplayName()} BTHome payload is encrypted; skipping decode`);
+      return null;
+    }
+    let index = 1;
+
+    let windSpeedCount = 0;
+
+    while (index < buffer.length) {
+      const objectId = buffer[index++];
+      switch (objectId) {
+        case 0x00: // packet id uint8 (ignore)
+          if (index + 1 > buffer.length) return decoded;
+          index += 1;
+          break;
+        case 0x01: // battery % uint8 -> ratio
+          if (index + 1 > buffer.length) return decoded;
+          decoded.batteryRatio = Number.parseFloat((buffer.readUInt8(index) / 100).toFixed(2));
+          index += 1;
+          break;
+        case 0x45: // temperature C*0.1 int16 -> Kelvin
+          if (index + 2 > buffer.length) return decoded;
+          decoded.temperatureK = Number.parseFloat((273.15 + this.readI16LE(buffer, index) * 0.1).toFixed(2));
+          index += 2;
+          break;
+        case 0x2e: // humidity % uint8 -> ratio
+          if (index + 1 > buffer.length) return decoded;
+          decoded.humidityRatio = Number.parseFloat((buffer.readUInt8(index) / 100).toFixed(2));
+          index += 1;
+          break;
+        case 0x04: // pressure hPa*0.01 uint24 -> Pa
+          if (index + 3 > buffer.length) return decoded;
+          decoded.pressurePa = Number.parseFloat((this.readU24LE(buffer, index) * 0.01 * 100).toFixed(2));
+          index += 3;
+          break;
+        case 0x05: // illuminance lux*0.01 uint24 -> lux
+          if (index + 3 > buffer.length) return decoded;
+          decoded.illuminanceLux = Number.parseFloat((this.readU24LE(buffer, index) * 0.01).toFixed(2));
+          index += 3;
+          break;
+        case 0x46: // UV index *0.1 uint8
+          if (index + 1 > buffer.length) return decoded;
+          decoded.uvIndex = Number.parseFloat((buffer.readUInt8(index) * 0.1).toFixed(1));
+          index += 1;
+          break;
+        case 0x20: // rain status bool uint8
+          if (index + 1 > buffer.length) return decoded;
+          decoded.isRaining = buffer.readUInt8(index) !== 0;
+          index += 1;
+          break;
+        case 0x5f: // precipitation mm*0.1 uint16
+          if (index + 2 > buffer.length) return decoded;
+          decoded.precipitationMm = Number.parseFloat((this.readU16LE(buffer, index) * 0.1).toFixed(1));
+          index += 2;
+          break;
+        case 0x5e: // wind direction deg*0.01 uint16 -> radians
+          if (index + 2 > buffer.length) return decoded;
+          decoded.windDirectionRad = Number.parseFloat(((this.readU16LE(buffer, index) * 0.01 * Math.PI) / 180).toFixed(4));
+          index += 2;
+          break;
+        case 0x44: { // wind/gust speed m/s*0.01 uint16; appears twice
+          if (index + 2 > buffer.length) return decoded;
+          const value = Number.parseFloat((this.readU16LE(buffer, index) * 0.01).toFixed(2));
+          if (windSpeedCount === 0) decoded.windSpeed = value;
+          else if (windSpeedCount === 1) decoded.windGust = value;
+          windSpeedCount += 1;
+          index += 2;
+          break;
+        }
+        case 0x08: // optional dew point C*0.01 int16 (ignored)
+          if (index + 2 > buffer.length) return decoded;
+          index += 2;
+          break;
+        case 0x0c: // optional capacitor voltage V*0.001 uint16 (ignored)
+          if (index + 2 > buffer.length) return decoded;
+          index += 2;
+          break;
+        default:
+          this.debug(`${this.getDisplayName()} unsupported BTHome object 0x${objectId.toString(16)}`);
+          return decoded;
+      }
+    }
+
+    return decoded;
+  }
+
+  propertiesChanged(props) {
+    const raw = this.getServiceData(this.constructor.BTHOME_SERVICE_ID);
+    if (!raw) return;
+    const buffer = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+    if (!this._ws90LoggedOnce) {
+      this._ws90LoggedOnce = true;
+      this.debug(`WS90 raw serviceData len=${buffer.length} hex=${buffer.toString("hex")}`);
+    }
+    const decoded = this.decodeWS90BTHomeData(buffer);
+    if (!decoded) return;
+
+    this.emitValuesFrom(decoded);
+  }
+}
+
+module.exports = ShellySBWS90CM;

package/sensor_classes/Victron/VictronSensor.js

@@ -83,6 +83,22 @@ const VictronIdentifier = require('./VictronIdentifier.js');
               alarm: `0x${alarm.toString(16).padStart(8,"0")}`,
               alarmstate: 'alert'})
     }
+
+    _getOperationMode(buff, offset=0){
+        const code = buff.readUInt8(offset)
+        return {
+            code: code,
+            message: VC.OperationMode.get(code)
+        }
+    }
+
+    _getChargerError(buff, offset=1){
+        const code = buff.readUInt8(offset)
+        return {
+            code: code,
+            message: VC.ChargerError.get(code)
+        }
+    }
    async init(){
         await super.init()
         this.addParameter(

package/sensor_classes/VictronACCharger.js

@@ -29,10 +29,12 @@ class VictronACCharger extends VictronSensor{
         this.addDefaultParam("id")
 
         this.addMetadatum('state','', 'device state', 
-            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
-            .default= "electrical.chargers.{id}.state"
+            (buff)=>{return this._getOperationMode(buff)})
+        .default= "electrical.chargers.{id}.state"
+
         this.addMetadatum('chargerError','', 'charger error code', 
-            (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
+            (buff)=>{return this._getChargerError(buff)}
+        )
             .default= "electrical.chargers.{id}.error"
 
         this.addMetadatum('batt1','V', 'battery 1 voltage')

package/sensor_classes/VictronDCDCConverter.js

@@ -8,13 +8,13 @@ class VictronDCDCConverter extends VictronSensor{
     initSchema(){
         super.initSchema()
         this.addDefaultParam("id")
+        this.addMetadatum('state','', 'device state', 
+                (buff)=>{return this._getOperationMode(buff)})
+        .default= "electrical.chargers.{id}.state"
 
-        this.addMetadatum('deviceState','', 'device state', 
-                (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
-        .default="electrical.chargers.{id}.state"
-        this.addMetadatum('chargerError','', 'charger error',
-                (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
-        .default="electrical.chargers.{id}.error"
+        this.addMetadatum('chargerError','', 'charger error code', 
+                (buff)=>{return this._getChargerError(buff)})
+        .default= "electrical.chargers.{id}.error"
 
         this.addMetadatum('inputVoltage','V', 'input voltage', 
                 (buff)=>{return this.NaNif(buff.readUInt16LE(2),0xFFFF)/100})

package/sensor_classes/VictronInverter.js

@@ -9,13 +9,13 @@ class VictronInverter extends VictronSensor{
     initSchema(){
         super.initSchema()
         this.addDefaultParam("id")
-
-        this.addMetadatum('deviceState','', 'inverter device state', 
-            (buff)=>{return VC.OperationMode.get(buff.readIntU8(0))})
-            .default="electrical.inverters.{id}.state"
+        this.addMetadatum('state','', 'inverter device state', 
+            (buff)=>{return this._getOperationMode(buff)}
+        )
+        .default="electrical.inverters.{id}.state"
 
         const md = this.addMetadatum('alarmReason','', 'reason for alarm',
-            (buff)=>{return buff.readIntU16LE(1)})
+            (buff)=>{return buff.readUInt16LE(1)})
         .default="electrical.inverters.{id}.alarm"
 
         this.addDefaultPath('dcVoltage','electrical.inverters.dc.voltage') 

package/sensor_classes/VictronInverterRS.js

@@ -10,14 +10,16 @@ class VictronInverterRS extends VictronSensor{
 
      initSchema() {
         super.initSchema()
-        this.addDefaultParam("id")
-        this.addMetadatum('deviceState','', 'inverter device state', 
-            (buff)=>{return VC.OperationMode.get(buff.readIntU8(0))})
-            .default='electrical.inverters.{id}.state'    
-
-        const md = this.addMetadatum('chargerError','', 'charger error',
-            (buff)=>{return VC.ChargerError(buff.readIntU8(1))})
-            md.default='electrical.inverters.{id}.error'
+        this.addDefaultParam("id")        
+        this.addMetadatum('state','', 'device state', 
+            (buff)=>{return this._getOperationMode(buff)}
+        )
+        .default='electrical.inverters.{id}.state'    
+        
+        this.addMetadatum('chargerError','', 'charger error code', 
+            (buff)=>{return this._getChargerError(buff)}
+        )
+        .default='electrical.inverters.{id}.error'
 
         this.addMetadatum('batteryVoltage','V', 'battery voltage', 
             (buff)=>{return this.NaNif(buff.readInt16LE(2),0x7FFF)/100})

package/sensor_classes/VictronOrionXS.js

@@ -10,11 +10,11 @@ class VictronOrionXS extends VictronSensor{
         super.initSchema()
         this.addDefaultParam("id")
         this.addMetadatum('deviceState','', 'device state', 
-            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+            (buff)=>{return this._getOperationMode(buff)})
             .default="electrical.chargers.{id}.state"
-
-        this.addMetadatum('chargerError','', 'charger error',
-            (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
+    
+        this.addMetadatum('chargerError','', 'charger error code', 
+            (buff)=>{return this._getChargerError(buff)})
             .default="electrical.chargers.{id}.error"
 
         this.addMetadatum('outputVoltage','V', 'output voltage', 

package/sensor_classes/VictronSmartBatteryProtect.js

@@ -24,13 +24,15 @@ class VictronSmartBatteryProtect extends VictronSensor{
     initSchema(){
         super.initSchema()
         this.addDefaultParam("id")
+
         this.addMetadatum('deviceState','', 'device state', 
-            (buff)=>{return VC.OperationMode.get(buff.readUInt8(1))})
+            (buff)=>{return this._getOperationMode(buff)})
+
         this.addMetadatum('outputStatus','', 'output status', //TODO
             (buff)=>{return (buff.readUInt8(2))})
 
-        this.addMetadatum('chargerError','', 'charger error',
-            (buff)=>{return VC.ChargerError.get(buff.readUInt8(3))})
+        this.addMetadatum('chargerError','', 'charger error', 
+            (buff)=>{return this._getChargerError(buff,3)})
         this.addMetadatum('alarmReason','', 'alarm reason', 
             (buff)=>{return buff.readUInt16LE(4)})
         this.addMetadatum('warningReason','', 'warning reason', //TODO

package/sensor_classes/VictronSolarCharger.js

@@ -9,11 +9,17 @@ class VictronSolarCharger extends VictronSensor{
         this.addDefaultParam("id")
     
         this.addMetadatum('chargeState','', 'charge state', 
-        (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+            (buff)=>{
+                const code = buff.readUInt8(0)
+                return {
+                    code: code,
+                    message: VC.OperationMode.get(code)
+                }
+            })
         .default="electrical.solar.{id}.state"
     
         this.addMetadatum('chargerError','', 'charger error',
-            (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
+            (buff)=>{return this._getChargerError(buff)})
             .default="electrical.solar.{id}.error"
 
         this.addMetadatum('voltage','V', 'charger battery voltage', 

package/sensor_classes/VictronVEBus.js

@@ -9,7 +9,7 @@ class VictronVEBus extends VictronSensor{
     initSchema(){
         super.initSchema()
         this.addMetadatum('chargeState','', 'charge state', 
-            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+            (buff)=>{ return this._getOperationMode(buff)})
             
         this.addMetadatum('veBusError','', 'VE bus error',
             (buff)=>{return buff.readUInt8(1)}) //TODO