signalk-rec-bms 1.1.6 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-rec-bms",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "SignalK plugin for REC-BMS",
   "main": "plugin/index.js",
   "scripts": {

package/plugin/index.js

@@ -6,25 +6,97 @@ const connection = require('./lib/connection');
 module.exports = function(app) {
   let conn;
   let pluginOptions;
-  let commsHandler;
+
+  function publishMeta(options) {
+    const p = options.deltaPrefix || "electrical.batteries.bms";
+
+    const meta = [
+      // Live data
+      { path: `${p}.minCellVoltage`,                 value: { units: "V",     description: "Minimum cell voltage across all cells" } },
+      { path: `${p}.maxCellVoltage`,                 value: { units: "V",     description: "Maximum cell voltage across all cells" } },
+      { path: `${p}.cellVoltageDifference`,          value: { units: "V",     description: "Difference between maximum and minimum cell voltage" } },
+      { path: `${p}.numBMSUnits`,                    value: {                 description: "Number of ABMS units connected in series" } },
+      { path: `${p}.bmsTemperature`,                 value: { units: "K",     description: "BMS board internal temperature" } },
+      { path: `${p}.slaveAddress`,                   value: {                 description: "RS-485 address of the BMS unit with the lowest cell voltage" } },
+      { path: `${p}.minCellNumber`,                  value: {                 description: "Cell number with the lowest voltage" } },
+      { path: `${p}.maxCellNumber`,                  value: {                 description: "Cell number with the highest voltage" } },
+      { path: `${p}.maxTempSensBmsAddress`,          value: {                 description: "RS-485 address of BMS unit with the highest temperature sensor reading" } },
+      { path: `${p}.maxTempSensNumber`,              value: {                 description: "Sensor number with the highest temperature reading" } },
+      { path: `${p}.id`,                             value: {                 description: "Device identification string" } },
+      { path: `${p}.errorPresent`,                   value: {                 description: "1 if an error is active, 0 if none" } },
+      { path: `${p}.errorAddress`,                   value: {                 description: "RS-485 address of BMS unit reporting the error" } },
+      { path: `${p}.errorCode`,                      value: {                 description: "Error code (1-16)" } },
+      { path: `${p}.errorSource`,                    value: {                 description: "Cell or sensor number associated with the error" } },
+      // Derived
+      { path: `${p}.power`,                          value: { units: "W",     description: "Instantaneous power (voltage × current)" } },
+      { path: `${p}.capacity.remaining`,             value: { units: "Ah",    description: "Estimated capacity remaining" } },
+      { path: `${p}.capacity.nominal`,               value: { units: "Ah",    description: "Nominal battery pack capacity as configured in BMS" } },
+      { path: `${p}.capacity.timeRemaining`,         value: { units: "s",     description: "Estimated time to full discharge at current load" } },
+      { path: `${p}.timeToFull`,                     value: { units: "s",     description: "Estimated time to full charge at current charge rate" } },
+      // Battery
+      { path: `${p}.batteryCycleCount`,              value: {                 description: "Number of full charge/discharge cycles" } },
+      // Voltage thresholds
+      { path: `${p}.balEndVoltage`,                  value: { units: "V",     description: "Cell voltage at which balancing ends" } },
+      { path: `${p}.balStartVoltage`,                value: { units: "V",     description: "Cell voltage at which balancing starts" } },
+      { path: `${p}.maxAllowedCellVoltage`,          value: { units: "V",     description: "Cell over-voltage switch-off threshold" } },
+      { path: `${p}.maxAllowedVoltageHysteresis`,    value: { units: "V",     description: "Over-voltage switch-off hysteresis per cell" } },
+      { path: `${p}.minAllowedCellVoltage`,          value: { units: "V",     description: "Cell under-voltage switch-off threshold" } },
+      { path: `${p}.minAllowedVoltageHysteresis`,    value: { units: "V",     description: "Under-voltage switch-off hysteresis per cell" } },
+      { path: `${p}.endChargeVoltage`,               value: { units: "V",     description: "Cell end-of-charge voltage" } },
+      { path: `${p}.endChargeHysteresis`,            value: { units: "V",     description: "End-of-charge voltage hysteresis per cell" } },
+      { path: `${p}.endOfChargeCellDifference`,      value: { units: "V",     description: "Maximum allowed cell voltage difference at end of charge" } },
+      { path: `${p}.floatVoltageCoefficient`,        value: {                 description: "Float voltage coefficient (multiplier on charge voltage)" } },
+      { path: `${p}.maxAllowedCellVoltDiff`,         value: { units: "V",     description: "Maximum allowed cell voltage difference during operation" } },
+      // Temperature thresholds
+      { path: `${p}.cellOverTempSwitchOff`,          value: { units: "K",     description: "Cell over-temperature switch-off threshold" } },
+      { path: `${p}.underTempChargeDisable`,         value: { units: "K",     description: "Under-temperature charge disable threshold" } },
+      { path: `${p}.bmsOverTempSwitchOff`,           value: { units: "K",     description: "BMS board over-temperature switch-off threshold" } },
+      { path: `${p}.bmsOverTempSwitchOffHysteresis`, value: { units: "K",     description: "BMS board over-temperature switch-off hysteresis" } },
+      // Current sensor
+      { path: `${p}.currentSensorOffset`,            value: { units: "A",     description: "Current measurement zero offset" } },
+      { path: `${p}.currentSensorCoefficient`,       value: { units: "A/V",   description: "Voltage-to-current conversion coefficient" } },
+      // SOC
+      { path: `${p}.socHysteresis`,                  value: { units: "ratio", description: "SOC end-of-charge hysteresis (0-1)" } },
+      { path: `${p}.socReset`,                       value: { units: "ratio", description: "SOC value applied on manual reset (0-1)" } },
+      // Outputs
+      { path: `${p}.relay1Voltage`,                  value: { units: "V",     description: "Relay 1 activation voltage threshold" } },
+      { path: `${p}.relay1Hysteresis`,               value: { units: "V",     description: "Relay 1 voltage hysteresis" } },
+      { path: `${p}.opto2Voltage`,                   value: { units: "V",     description: "Optocoupler 2 activation voltage threshold" } },
+      { path: `${p}.opto2Hysteresis`,                value: { units: "V",     description: "Optocoupler 2 voltage hysteresis" } },
+      // Victron/Wakespeed
+      { path: `${p}.chargeCoefficient`,              value: {                 description: "Charge current coefficient (0-5C)" } },
+      { path: `${p}.dischargeCoefficient`,           value: {                 description: "Discharge current coefficient (0-5C)" } },
+      { path: `${p}.numberOfInverterDevices`,        value: {                 description: "Number of inverter/charger devices on the CAN bus" } },
+      { path: `${p}.maxChargeCurrent`,               value: { units: "A",     description: "Maximum charge current per inverter device" } },
+      { path: `${p}.maxDischargeCurrent`,            value: { units: "A",     description: "Maximum discharge current per inverter device" } },
+      { path: `${p}.minDischargeCellVoltage`,        value: { units: "V",     description: "Cell under-voltage discharge protection threshold" } },
+      // ABMS
+      { path: `${p}.deviceName`,                     value: {                 description: "BMS device identifier (serial number formatted as 1A-XXXX)" } },
+      { path: `${p}.abmsSoftwareVersion`,            value: {                 description: "ABMS firmware software version" } },
+      { path: `${p}.abmsHardwareVersion`,            value: {                 description: "ABMS hardware version" } },
+      { path: `${p}.time`,                           value: {                 description: "BMS real-time clock time (hh:mm:ss)" } },
+      { path: `${p}.date`,                           value: {                 description: "BMS real-time clock date (dd.mm.yyyy)" } },
+      { path: `${p}.balancingCellNumber`,            value: {                 description: "Cell number currently being balanced" } },
+      { path: `${p}.calibrationOffsetCell1`,         value: { units: "V",     description: "Voltage calibration offset for cell 1" } },
+      { path: `${p}.calibrationOffsetCell2`,         value: { units: "V",     description: "Voltage calibration offset for cell 2" } },
+      { path: `${p}.calibrationOffsetCell3`,         value: { units: "V",     description: "Voltage calibration offset for cell 3" } },
+      { path: `${p}.calibrationOffsetCell4`,         value: { units: "V",     description: "Voltage calibration offset for cell 4" } },
+      // Error log
+      { path: `${p}.errorLogData`,                   value: {                 description: "Last error log entry (format: code,cell;hh:mm:ss;dd.mm.yyyy)" } },
+      { path: `${p}.errorLogDelete`,                 value: {                 description: "Error log delete flag (set to 1 to clear, then restart BMS)" } },
+      { path: `${p}.vmaxExceededCount`,              value: {                 description: "Number of times cell over-voltage threshold was exceeded" } },
+      { path: `${p}.vminExceededCount`,              value: {                 description: "Number of times cell under-voltage threshold was exceeded" } },
+    ];
+
+    app.handleMessage("signalk-rec-bms", {
+      updates: [{ meta }]
+    });
+  }
 
   function publishDelta(delta) {
-    let mergedConfig = {};
-    if (pluginOptions && pluginOptions.deltas) {
-      if (pluginOptions.deltas.common) {
-        Object.assign(mergedConfig, pluginOptions.deltas.common);
-      }
-      if (pluginOptions.deltas.ws) {
-        Object.assign(mergedConfig, pluginOptions.deltas.ws);
-      }
-      if (pluginOptions.deltas.serial) {
-        Object.assign(mergedConfig, pluginOptions.deltas.serial);
-      }
-    }
-  
     const precision = 5;
     const factor = Math.pow(10, precision);
-  
+
     delta.updates.forEach(update => {
       update.values.forEach(item => {
         if (typeof item.value === "number") {
@@ -32,7 +104,7 @@ module.exports = function(app) {
         }
       });
     });
-  
+
     if (delta && delta.updates && delta.updates.some(u => u.values.length > 0)) {
       app.debug(`[INDEX] Publishing delta: ${JSON.stringify(delta)}`);
       app.handleMessage("signalk-rec-bms", delta, "v1");
@@ -40,7 +112,7 @@ module.exports = function(app) {
       app.debug("[INDEX] Delta empty after processing, not publishing.");
     }
   }
-  
+
   var plugin = {
     id: "signalk-rec-bms",
     name: "SignalK-REC-BMS",
@@ -50,6 +122,7 @@ module.exports = function(app) {
       pluginOptions = options;
       app.debug(`[INDEX] START invoked with options: ${JSON.stringify(options)}`);
       app.setPluginStatus("Connecting to BMS…");
+      publishMeta(options);
       conn = connection(options, app, publishDelta);
       conn.start(options);
     },
@@ -64,4 +137,4 @@ module.exports = function(app) {
   };
 
   return plugin;
-};
+};

package/plugin/lib/schema.js

@@ -54,6 +54,11 @@ module.exports = {
       title: "Delta Path Prefix",
       type: "string",
       default: "electrical.batteries.bms"
+    },
+    numTempSensors: {
+      title: "Number of Temperature Sensors",
+      type: "number",
+      default: 1
     }
   }
-};
+};

package/plugin/lib/serial/modules/abms.js

@@ -208,7 +208,7 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.name`, value: "1A-" + d.abmsSerialNumber }
+            { path: `${prefix}.deviceName`, value: "1A-" + d.abmsSerialNumber }
           ]
         }]
       };
@@ -297,4 +297,4 @@ module.exports = {
   parseTIMEResponse,
   parseDATEResponse,
   parseWCBIResponse
-};
+};

package/plugin/lib/serial/modules/array.js

@@ -123,20 +123,22 @@ function parsePTEMResponse(packets) {
   }
 
   const sizePacket = packets.find(p => p[3] === 1);
-  const dataPacket = packets.find(p => p[3] >= 4 && (p.length - 7) % 4 === 0); // Payload divisible by 4 bytes
+  const dataPackets = packets.filter(p => p[3] !== 1);
 
-  if (!sizePacket || !dataPacket) {
+  if (!sizePacket || dataPackets.length === 0) {
     return null;
   }
 
   const numBMSUnits = parseInt(sizePacket.slice(4, 5).toString('utf8'), 10);
-  const floatCount = (dataPacket.length - 7) / 4;
 
   let temperature = [];
-  for (let i = 0; i < floatCount; i++) {
-    const offset = 4 + i * 4;
-    temperature.push(dataPacket.readFloatLE(offset));
-  }
+  dataPackets.forEach(packet => {
+    const floatCount = (packet.length - 7) / 4;
+    for (let i = 0; i < floatCount; i++) {
+      const offset = 4 + i * 4;
+      temperature.push(packet.readFloatLE(offset));
+    }
+  });
 
   const result = {
     type: "PTEM",
@@ -235,7 +237,7 @@ function getDelta(parsed, options, app) {
   let vesselId = (typeof app.getSelfId === 'function') ? app.getSelfId() : (app.selfId || "self");
   const context = `vessels.${vesselId}`;
   const prefix = options.deltaPrefix || "electrical.batteries.bms";
-  
+
   let delta = null;
   switch (parsed.type) {
     case "LCD1": {
@@ -245,13 +247,13 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.minCellVoltage`, value: d.minVoltage },
-            { path: `${prefix}.maxCellVoltage`, value: d.maxVoltage },
-            { path: `${prefix}.current`, value: d.current },
-            //{ path: `${prefix}.cellTemperature`, value: d.temperature },
-            { path: `${prefix}.voltage`, value: d.packVoltage },
-            { path: `${prefix}.stateOfCharge`, value: d.soc },
-            { path: `${prefix}.stateOfHealth`, value: d.soh }
+            { path: `${prefix}.minCellVoltage`,          value: d.minVoltage },
+            { path: `${prefix}.maxCellVoltage`,          value: d.maxVoltage },
+            { path: `${prefix}.current`,                 value: d.current },
+            //{ path: `${prefix}.temperature`,           value: d.temperature },
+            { path: `${prefix}.voltage`,                 value: d.packVoltage },
+            { path: `${prefix}.capacity.stateOfCharge`,  value: d.soc },
+            { path: `${prefix}.capacity.stateOfHealth`,  value: d.soh }
           ]
         }]
       };
@@ -264,11 +266,12 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.slaveAddress`, value: d.minCellBmsAddress },
-            { path: `${prefix}.slaveCellCount`, value: d.maxCellNumber - d.minCellNumber + 1 },
-            { path: `${prefix}.maxTempSensBmsAddress`, value: d.maxTempSensBmsAddress },
-            { path: `${prefix}.maxTempSensNumber`, value: d.maxTempSensNumber },
-            { path: `${prefix}.ampHourUsed`, value: d.ah }
+            { path: `${prefix}.slaveAddress`,                value: d.minCellBmsAddress },
+            { path: `${prefix}.minCellNumber`,               value: d.minCellNumber },
+            { path: `${prefix}.maxCellNumber`,               value: d.maxCellNumber },
+            { path: `${prefix}.maxTempSensBmsAddress`,       value: d.maxTempSensBmsAddress },
+            { path: `${prefix}.maxTempSensNumber`,           value: d.maxTempSensNumber },
+            { path: `${prefix}.capacity.dischargeSinceFull`, value: d.ah * 3600 }
           ]
         }]
       };
@@ -291,50 +294,62 @@ function getDelta(parsed, options, app) {
       let values = [
         { path: `${prefix}.numBMSUnits`, value: d.numBMSUnits }
       ];
+      let metaEntries = [];
       d.cellVoltages.forEach((voltage, index) => {
-        values.push({ path: `${prefix}.cellVoltage${index + 1}`, value: voltage });
+        const path = `${prefix}.cellVoltage${index + 1}`;
+        values.push({ path, value: voltage });
+        metaEntries.push({ path, value: { units: "V", description: `Voltage of cell ${index + 1}` } });
       });
       delta = {
         context,
         updates: [{
           timestamp: new Date().toISOString(),
-          values: values
+          values,
+          meta: metaEntries
         }]
       };
       break;
     }
     case "PTEM": {
       const d = parsed.data;
+      const sensorCount = (options && options.numTempSensors) ? options.numTempSensors : 1;
+      const temperatures = d.temperature.slice(0, sensorCount);
       let values = [
         { path: `${prefix}.numBMSUnits`, value: d.numBMSUnits }
       ];
-    
-      d.temperature.forEach((temp, index) => {
-        values.push({ path: `${prefix}.cellTemperature${index + 1}`, value: temp });
+      let metaEntries = [];
+      temperatures.forEach((temp, index) => {
+        const path = `${prefix}.cellTemperature${index + 1}`;
+        values.push({ path, value: temp + 273.15 });
+        metaEntries.push({ path, value: { units: "K", description: `Temperature of sensor ${index + 1}` } });
       });
-    
       delta = {
         context,
         updates: [{
           timestamp: new Date().toISOString(),
-          values: values
+          values,
+          meta: metaEntries
         }]
       };
       break;
-    }    
+    }
     case "RINT": {
       const d = parsed.data;
       let values = [
         { path: `${prefix}.numBMSUnits`, value: d.numBMSUnits }
       ];
+      let metaEntries = [];
       d.resistances.forEach((res, index) => {
-        values.push({ path: `${prefix}.cellResistance${index + 1}`, value: res });
+        const path = `${prefix}.cellResistance${index + 1}`;
+        values.push({ path, value: res });
+        metaEntries.push({ path, value: { units: "Ohm", description: `Internal DC resistance of cell ${index + 1}` } });
       });
       delta = {
         context,
         updates: [{
           timestamp: new Date().toISOString(),
-          values: values
+          values,
+          meta: metaEntries
         }]
       };
       break;
@@ -346,7 +361,7 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.bmsTemperature`, value: d.bmsTemperature }
+            { path: `${prefix}.bmsTemperature`, value: d.bmsTemperature + 273.15 }
           ]
         }]
       };
@@ -361,13 +376,13 @@ function getDelta(parsed, options, app) {
           values: [
             { path: `${prefix}.errorPresent`, value: d.hasError },
             { path: `${prefix}.errorAddress`, value: d.bmsUnit },
-            { path: `${prefix}.errorCode`, value: d.errorCode },
-            { path: `${prefix}.errorSource`, value: d.cellOrSensor }
+            { path: `${prefix}.errorCode`,    value: d.errorCode },
+            { path: `${prefix}.errorSource`,  value: d.cellOrSensor }
           ]
         }]
       };
       break;
-    }    
+    }
 
     default:
       break;
@@ -379,15 +394,15 @@ function getDelta(parsed, options, app) {
    4. EXPORTS
    Export functions for building commands, parsing responses, and building deltas.
    ============================================================================ */
-   module.exports = {
-    buildCommand,
-    getDelta,
-    parseLCD1Response,
-    parseLCD3Response,
-    parseIDNResponse,
-    parseCELLResponse,
-    parsePTEMResponse,
-    parseRINTResponse,
-    parseBTEMResponse,
-    parseERROResponse
-  };  
+module.exports = {
+  buildCommand,
+  getDelta,
+  parseLCD1Response,
+  parseLCD3Response,
+  parseIDNResponse,
+  parseCELLResponse,
+  parsePTEMResponse,
+  parseRINTResponse,
+  parseBTEMResponse,
+  parseERROResponse
+};

package/plugin/lib/serial/modules/bat.js

@@ -90,7 +90,9 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.capacity`, value: d.capacity }
+            // Published in Ah. SK spec wants Joules for capacity.nominal but Ah is
+            // what the BMS provides and what is meaningful for battery management.
+            { path: `${prefix}.capacity.nominal`, value: d.capacity }
           ]
         }]
       };

package/plugin/lib/serial/modules/derived.js

@@ -9,29 +9,32 @@ module.exports = function Derived(app, sendDeltaCallback, config) {
     ? (base.endsWith('.') ? base : base + '.')
     : "";
 
+  // 'capacity' is stored internally in Ah (as received from capacity.nominal).
+  // 'ampHourUsed' is stored internally in Ah (converted from Coulombs off the stream).
+
   function computeAndSendDeltas() {
     if ([voltage, current, ampHourUsed, capacity].every(v => typeof v === 'number')) {
       const power = voltage * current;
       const ahRemaining = capacity - ampHourUsed;
 
       const values = [
-        { path: prefix + 'power',             value: power },
-        { path: prefix + 'ampHourRemaining', value: ahRemaining }
+        { path: prefix + 'power',              value: power },
+        { path: prefix + 'capacity.remaining', value: ahRemaining }
       ];
 
       if (current > 0 && ahRemaining < capacity) {
         const missingAh = capacity - ahRemaining;
         const timeToFull = (missingAh / current) * 3600;
-        values.push({ path: prefix + 'timeToFull', value: timeToFull });
-        values.push({ path: prefix + 'timeToEmpty', value: 0 });
+        values.push({ path: prefix + 'timeToFull',              value: timeToFull });
+        values.push({ path: prefix + 'capacity.timeRemaining',  value: 0 });
       } else if (current < 0 && ahRemaining > 0) {
         const timeToEmpty = (ahRemaining / Math.abs(current)) * 3600;
-        values.push({ path: prefix + 'timeToFull', value: 0 });
-        values.push({ path: prefix + 'timeToEmpty', value: timeToEmpty });
+        values.push({ path: prefix + 'timeToFull',              value: 0 });
+        values.push({ path: prefix + 'capacity.timeRemaining',  value: timeToEmpty });
       } else {
         // fallback when current is 0 or data is abnormal
-        values.push({ path: prefix + 'timeToFull', value: 0 });
-        values.push({ path: prefix + 'timeToEmpty', value: 0 });
+        values.push({ path: prefix + 'timeToFull',              value: 0 });
+        values.push({ path: prefix + 'capacity.timeRemaining',  value: 0 });
       }
 
       sendDeltaCallback({
@@ -46,10 +49,12 @@ module.exports = function Derived(app, sendDeltaCallback, config) {
   app.streambundle.getSelfStream(prefix + 'current').forEach(v => {
     if (typeof v === 'number') { current = v; computeAndSendDeltas(); }
   });
-  app.streambundle.getSelfStream(prefix + 'ampHourUsed').forEach(v => {
-    if (typeof v === 'number') { ampHourUsed = v; computeAndSendDeltas(); }
+  app.streambundle.getSelfStream(prefix + 'capacity.dischargeSinceFull').forEach(v => {
+    // value on stream is Coulombs; convert to Ah for internal arithmetic
+    if (typeof v === 'number') { ampHourUsed = v / 3600; computeAndSendDeltas(); }
   });
-  app.streambundle.getSelfStream(prefix + 'capacity').forEach(v => {
+  app.streambundle.getSelfStream(prefix + 'capacity.nominal').forEach(v => {
+    // value on stream is Ah
     if (typeof v === 'number') { capacity = v; computeAndSendDeltas(); }
   });
 

package/plugin/lib/serial/modules/temp.js

@@ -81,7 +81,7 @@ function getDelta(parsed, options, app) {
   let vesselId = (typeof app.getSelfId === 'function') ? app.getSelfId() : (app.selfId || "self");
   const context = `vessels.${vesselId}`;
   const prefix = options.deltaPrefix || "electrical.batteries.bms";
-  
+
   let delta = null;
   switch (parsed.type) {
     case "TMAX": {
@@ -91,7 +91,7 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.cellOverTempSwitchOff`, value: d.cellOverTempSwitchOff }
+            { path: `${prefix}.cellOverTempSwitchOff`, value: d.cellOverTempSwitchOff + 273.15 }
           ]
         }]
       };
@@ -104,7 +104,7 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.underTempChargeDisable`, value: d.underTempChargeDisable }
+            { path: `${prefix}.underTempChargeDisable`, value: d.underTempChargeDisable + 273.15 }
           ]
         }]
       };
@@ -117,7 +117,7 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.bmsOverTempSwitchOff`, value: d.bmsOverTempSwitchOff }
+            { path: `${prefix}.bmsOverTempSwitchOff`, value: d.bmsOverTempSwitchOff + 273.15 }
           ]
         }]
       };
@@ -130,7 +130,7 @@ function getDelta(parsed, options, app) {
         updates: [{
           timestamp: new Date().toISOString(),
           values: [
-            { path: `${prefix}.bmsOverTempSwitchOffHysteresis`, value: d.bmsOverTempSwitchOffHysteresis }
+            { path: `${prefix}.bmsOverTempSwitchOffHysteresis`, value: d.bmsOverTempSwitchOffHysteresis + 273.15 }
           ]
         }]
       };

package/public/index.html

@@ -24,20 +24,28 @@
     <div class="stats-panel">
       <div class="metric-box">
         <div class="metric-label">Capacity</div>
-        <div class="metric-value" id="capacity">--.-- Ah</div>
+        <div class="metric-value" id="capacity-nominal">--.-- Ah</div>
       </div>
       <div class="metric-box">
         <div class="metric-label">Amp Hours Remaining</div>
-        <div class="metric-value" id="ampHourRemaining">--.-- Ah</div>
+        <div class="metric-value" id="capacity-remaining">--.-- Ah</div>
+      </div>
+      <div class="metric-box">
+        <div class="metric-label">Time Remaining</div>
+        <div class="metric-value" id="capacity-timeRemaining">--.-- h</div>
       </div>
       <div class="metric-box">
         <div class="metric-label">Amp Hours Used</div>
-        <div class="metric-value" id="ampHourUsed">--.-- Ah</div>
+        <div class="metric-value" id="capacity-dischargeSinceFull">--.-- Ah</div>
       </div>
       <div class="metric-box">
         <div class="metric-label">State of Charge</div>
         <div class="metric-value" id="stateOfCharge">-- %</div>
       </div>
+      <div class="metric-box">
+        <div class="metric-label">State of Health</div>
+        <div class="metric-value" id="stateOfHealth">-- %</div>
+      </div>
       <div class="metric-box">
         <div class="metric-label">Pack Voltage</div>
         <div class="metric-value" id="voltage">--.-- V</div>
@@ -77,39 +85,38 @@
         <div id="cell-towers" class="towers-container"></div>
       </div>
       
-<div id="settings-view" class="content-view">
-  <div class="settings-container">
-    <h2 class="settings-title">BMS Settings</h2>
-    <div class="settings-section" id="settings-command-grid">
-    </div>
-    <div class="settings-section" style="margin-top: 25px;">
-      <h3>Manual BMS Command</h3>
-      <form id="command-form" class="settings-form-group">
-        <label for="command-input" class="settings-label">
-          Enter Command (e.g., <code>BVOL 3.25</code>)
-        </label>
-        <input
-          type="text"
-          id="command-input"
-          class="settings-input"
-          placeholder="Enter command like 'BVOL 3.25'"
-          required
-        />
-        <div class="settings-buttons">
-          <button type="submit" class="settings-button primary">Send Command</button>
+      <div id="settings-view" class="content-view">
+        <div class="settings-container">
+          <h2 class="settings-title">BMS Settings</h2>
+          <div class="settings-section" id="settings-command-grid">
+          </div>
+          <div class="settings-section" style="margin-top: 25px;">
+            <h3>Manual BMS Command</h3>
+            <form id="command-form" class="settings-form-group">
+              <label for="command-input" class="settings-label">
+                Enter Command (e.g., <code>BVOL 3.25</code>)
+              </label>
+              <input
+                type="text"
+                id="command-input"
+                class="settings-input"
+                placeholder="Enter command like 'BVOL 3.25'"
+                required
+              />
+              <div class="settings-buttons">
+                <button type="submit" class="settings-button primary">Send Command</button>
+              </div>
+            </form>
+            <div
+              id="command-response"
+              class="settings-form-group settings-label"
+              style="margin-top: 10px;"
+            ></div>
+          </div>
         </div>
-      </form>
-      <div
-        id="command-response"
-        class="settings-form-group settings-label"
-        style="margin-top: 10px;"
-      ></div>
+      </div>
     </div>
-
   </div>
-</div>
-
-
 
   <div class="info-box">
     <a href="https://github.com/ofernander/signalk-rec-bms" target="_blank">signalk-rec-bms on GitHub</a>
@@ -123,7 +130,7 @@
       document.getElementById('nav-settings').classList.remove('active');
     });
 
-      document.getElementById('nav-settings').addEventListener('click', function() {
+    document.getElementById('nav-settings').addEventListener('click', function() {
       document.getElementById('status-view').classList.remove('active');
       document.getElementById('settings-view').classList.add('active');
       document.getElementById('nav-settings').classList.add('active');

package/public/js/main.js

@@ -14,18 +14,19 @@ class BMSSystem {
       voltage: null,
       current: null,
       power: null,
-      stateOfCharge: null,
-      stateOfHealth: null,
+      'capacity.stateOfCharge': null,
+      'capacity.stateOfHealth': null,
+      'capacity.remaining': null,
+      'capacity.dischargeSinceFull': null,
+      'capacity.nominal': null,
+      'capacity.timeRemaining': null,
       cellVoltages: {},
       cellResistances: {},
       cellVoltageDifference: null,
       bmsTemperature: null,
       cellTemperature1: null,
       maxCellVoltage: null,
-      minCellVoltage: null,
-      ampHourRemaining: null,
-      ampHourUsed: null,
-      capacity: null
+      minCellVoltage: null
     };
   }
 
@@ -38,16 +39,27 @@ class BMSSystem {
   }
 
   cacheDomElements() {
-    const metrics = [
-      'voltage', 'current', 'power', 'stateOfCharge', 'cellVoltageDifference', 'bmsTemperature', 'cellTemperature1',
-      'maxCellVoltage', 'minCellVoltage', 'ampHourRemaining',
-      'ampHourUsed', 'capacity'
-    ];
-
-    metrics.forEach(metric => {
-      this.dom.metricElements[metric] = document.getElementById(metric);
-      if (!this.dom.metricElements[metric]) {
-        console.warn(`Missing metric element: ${metric}`);
+    const metricMap = {
+      'voltage':                     'voltage',
+      'current':                     'current',
+      'power':                       'power',
+      'capacity.stateOfCharge':      'stateOfCharge',
+      'capacity.stateOfHealth':      'stateOfHealth',
+      'cellVoltageDifference':       'cellVoltageDifference',
+      'bmsTemperature':              'bmsTemperature',
+      'cellTemperature1':            'cellTemperature1',
+      'maxCellVoltage':              'maxCellVoltage',
+      'minCellVoltage':              'minCellVoltage',
+      'capacity.remaining':          'capacity-remaining',
+      'capacity.dischargeSinceFull': 'capacity-dischargeSinceFull',
+      'capacity.nominal':            'capacity-nominal',
+      'capacity.timeRemaining':      'capacity-timeRemaining'
+    };
+
+    Object.entries(metricMap).forEach(([key, id]) => {
+      this.dom.metricElements[key] = document.getElementById(id);
+      if (!this.dom.metricElements[key]) {
+        console.warn(`Missing metric element for key: ${key} (id: ${id})`);
       }
     });
   }
@@ -88,33 +100,58 @@ class BMSSystem {
       if (el) el.textContent = value !== null ? `${value.toFixed(2)}${unit}` : "--";
     };
 
-    setValue(this.dom.metricElements.voltage, this.liveData.voltage, "V");
-    setValue(this.dom.metricElements.current, this.liveData.current, "A");
-    setValue(this.dom.metricElements.power, this.liveData.power, "W");
+    setValue(this.dom.metricElements['voltage'], this.liveData.voltage, "V");
+    setValue(this.dom.metricElements['current'], this.liveData.current, "A");
+    setValue(this.dom.metricElements['power'], this.liveData.power, "W");
 
     setValue(
-      this.dom.metricElements.stateOfCharge,
-      this.liveData.stateOfCharge !== null ? this.liveData.stateOfCharge * 100 : null,
+      this.dom.metricElements['capacity.stateOfCharge'],
+      this.liveData['capacity.stateOfCharge'] !== null ? this.liveData['capacity.stateOfCharge'] * 100 : null,
       "%"
     );
     setValue(
-      this.dom.metricElements.stateOfHealth,
-      this.liveData.stateOfHealth !== null ? this.liveData.stateOfHealth * 100 : null,
+      this.dom.metricElements['capacity.stateOfHealth'],
+      this.liveData['capacity.stateOfHealth'] !== null ? this.liveData['capacity.stateOfHealth'] * 100 : null,
       "%"
     );
 
-    if (this.dom.metricElements.cellVoltageDifference) {
+    if (this.dom.metricElements['cellVoltageDifference']) {
       const v = this.liveData.cellVoltageDifference;
-      this.dom.metricElements.cellVoltageDifference.textContent = v !== null ? `${v.toFixed(4)}V` : "--";
+      this.dom.metricElements['cellVoltageDifference'].textContent = v !== null ? `${v.toFixed(4)}V` : "--";
     }
 
-    setValue(this.dom.metricElements.bmsTemperature, this.liveData.bmsTemperature, "°C");
-    setValue(this.dom.metricElements.cellTemperature1, this.liveData.cellTemperature1, "°C");
-    setValue(this.dom.metricElements.maxCellVoltage, this.liveData.maxCellVoltage, "V");
-    setValue(this.dom.metricElements.minCellVoltage, this.liveData.minCellVoltage, "V");
-    setValue(this.dom.metricElements.ampHourRemaining, this.liveData.ampHourRemaining, "Ah");
-    setValue(this.dom.metricElements.ampHourUsed, this.liveData.ampHourUsed, "Ah");
-    setValue(this.dom.metricElements.capacity, this.liveData.capacity, "Ah");
+    // Values arrive in Kelvin; subtract 273.15 for °C display
+    // Note: stopgap until frontend rewrite — SK will handle unit display natively
+    setValue(
+      this.dom.metricElements['bmsTemperature'],
+      this.liveData.bmsTemperature !== null ? this.liveData.bmsTemperature - 273.15 : null,
+      "°C"
+    );
+    setValue(
+      this.dom.metricElements['cellTemperature1'],
+      this.liveData.cellTemperature1 !== null ? this.liveData.cellTemperature1 - 273.15 : null,
+      "°C"
+    );
+
+    setValue(this.dom.metricElements['maxCellVoltage'], this.liveData.maxCellVoltage, "V");
+    setValue(this.dom.metricElements['minCellVoltage'], this.liveData.minCellVoltage, "V");
+
+    setValue(this.dom.metricElements['capacity.nominal'], this.liveData['capacity.nominal'], "Ah");
+    setValue(this.dom.metricElements['capacity.remaining'], this.liveData['capacity.remaining'], "Ah");
+
+    // dischargeSinceFull arrives in Coulombs; display as Ah
+    setValue(
+      this.dom.metricElements['capacity.dischargeSinceFull'],
+      this.liveData['capacity.dischargeSinceFull'] !== null ? this.liveData['capacity.dischargeSinceFull'] / 3600 : null,
+      "Ah"
+    );
+
+    // timeRemaining arrives in seconds; display as hours
+    setValue(
+      this.dom.metricElements['capacity.timeRemaining'],
+      this.liveData['capacity.timeRemaining'] !== null ? this.liveData['capacity.timeRemaining'] / 3600 : null,
+      "h"
+    );
   }
 
   connectWebSocket() {
@@ -123,19 +160,19 @@ class BMSSystem {
       const ws = new WebSocket(
         `${wsScheme}://${window.location.host}/signalk/v1/stream?subscribe=self&path=electrical.batteries.bms.*`
       );
-  
+
       ws.onopen = () => console.log("WebSocket connected");
       ws.onerror = (error) => console.error("WebSocket error:", error);
       ws.onclose = () => console.log("WebSocket connection closed");
-  
+
       ws.onmessage = (event) => {
         const delta = JSON.parse(event.data);
         if (!delta.updates) return;
-  
+
         delta.updates.forEach(update => {
           update.values?.forEach(({ path, value }) => {
             if (!path.startsWith(this.prefix)) return;
-  
+
             const key = path.slice(this.prefix.length);
             if (key in this.liveData) {
               this.liveData[key] = value;
@@ -146,7 +183,7 @@ class BMSSystem {
             }
           });
         });
-  
+
         this.updateMetrics();
         CellVisualizer.updateAllCells({
           cellVoltages: this.liveData.cellVoltages,
@@ -156,7 +193,7 @@ class BMSSystem {
     } catch (error) {
       console.error("WebSocket initialization failed:", error);
     }
-  }  
+  }
 }
 
 document.addEventListener('DOMContentLoaded', () => {

package/public/js/settings.js

@@ -1,5 +1,7 @@
 export class BMSSettings {
   constructor() {
+    this.tempCommands = new Set(['TMAX', 'TMIN', 'TBAL', 'BMTH']);
+
     this.commandGroups = [
       {
         title: "Voltage Settings",
@@ -54,7 +56,7 @@ export class BMSSettings {
       IOFF: "currentSensorOffset",
       IOJA: "currentSensorCoefficient",
       CYCL: "batteryCycleCount",
-      CAPA: "capacity",
+      CAPA: "capacity.nominal",
       CHEM: "chemistry",
       SOCH: "socHysteresis",
       SOCS: "socReset",
@@ -72,7 +74,7 @@ export class BMSSettings {
       CAL2: "calibrationOffsetCell2",
       CAL3: "calibrationOffsetCell3",
       CAL4: "calibrationOffsetCell4",
-      SERI: "name",
+      SERI: "deviceName",
       TIME: "time",
       DATE: "date",
       RSBR: "balancingCellNumber"
@@ -155,24 +157,23 @@ export class BMSSettings {
       });
     });
 
-  container.querySelectorAll("button[data-command]").forEach(button => {
-    button.addEventListener("click", async () => {
-      const cmd = button.getAttribute("data-command");
-      const inputField = document.getElementById(cmd);
-      const value = inputField.value.trim();
-      if (!value) return;
-  
-      const response = await this.sendCommand(`${cmd} ${value}`);
-      const path = this.commandToDeltaPath[cmd];
-      const success = response && typeof response === 'object' &&
-      Object.keys(response).length > 0;
-
-      inputField.value = success ? "OK" : "FAIL";
-  
-      setTimeout(() => this.prefillValues(), 5000);
+    container.querySelectorAll("button[data-command]").forEach(button => {
+      button.addEventListener("click", async () => {
+        const cmd = button.getAttribute("data-command");
+        const inputField = document.getElementById(cmd);
+        const value = inputField.value.trim();
+        if (!value) return;
+
+        const response = await this.sendCommand(`${cmd} ${value}`);
+        const success = response && typeof response === 'object' &&
+          Object.keys(response).length > 0;
+
+        inputField.value = success ? "OK" : "FAIL";
+
+        setTimeout(() => this.prefillValues(), 5000);
+      });
     });
-  });
-}  
+  }
 
   async prefillValues() {
     try {
@@ -185,10 +186,16 @@ export class BMSSettings {
           if (!field) continue;
 
           const path = this.commandToDeltaPath[cmd];
-          const val = bmsData[path]?.value;
+          if (!path) continue;
+
+          // Support dot-notation paths (e.g. "capacity.nominal")
+          const val = path.split('.').reduce((obj, key) => obj?.[key], bmsData)?.value;
 
           if (val !== undefined) {
-            field.value = val;
+            // Temperature values are stored in Kelvin; display in °C for user
+            field.value = this.tempCommands.has(cmd)
+              ? (val - 273.15).toFixed(3)
+              : val;
           }
         }
       }