signalk-rec-bms 1.1.1 → 1.1.3

package/README.md

@@ -1,6 +1,6 @@
 # signalk-rec-bms
 
-![alt text](https://github.com/ofernander/signalk-rec-bms/blob/main/public/assets/images/rec-sk.png)
+![alt text](https://raw.githubusercontent.com/ofernander/signalk-rec-bms/refs/heads/main/public/assets/images/rec-sk.png)
 
 ## Features
 
@@ -24,11 +24,11 @@ Tested with the 4 cell ABMS model only
   
 #### Serial connection:
 
-- RS485 to USB adapter with 5v output. The REC-BMS serial chip is not powered internally and you must supply 5v to power it. 
+- RS485 to USB adapter with 3v output. The REC-BMS serial chip is not powered internally and you must supply 3v to power it. 
 
-![alt text](https://github.com/ofernander/signalk-rec-bms/blob/main/public/assets/images/rs485.jpg)
+![alt text](https://raw.githubusercontent.com/ofernander/signalk-rec-bms/refs/heads/main/public/assets/images/rs485.jpg)
 
-![alt text](https://github.com/ofernander/signalk-rec-bms/blob/main/public/assets/images/bms_serial.png)
+![alt text](https://raw.githubusercontent.com/ofernander/signalk-rec-bms/refs/heads/main/public/assets/images/bms_serial.png)
 
 ## Dependencies
 

package/package.json

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

package/plugin/lib/schema.js

@@ -20,7 +20,7 @@ module.exports = {
         websocketURL: {
           title: "WebSocket URL",
           type: "string",
-          default: "ws://WiFi_module_ip/ws"
+          default: "ws://WiFi_module_IP/ws"
         }
       }
     },

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

@@ -132,8 +132,11 @@ function parseWCBIResponse(input) {
   if (!packet) {
     return null;
   }
-  const payload = packet.slice(4, packet.length - 3).toString('utf8');
+  const payload = packet.slice(4, packet.length - 3).toString('utf8').trim();
   const value = parseInt(payload, 10);
+  if (isNaN(value)) {
+    return null;
+  }
   const result = {
     type: "WCBI",
     data: { balancingCellNumber: value }
@@ -294,4 +297,4 @@ module.exports = {
   parseTIMEResponse,
   parseDATEResponse,
   parseWCBIResponse
-};
+};

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

@@ -35,8 +35,8 @@ function parseLCD1Response(input) {
       current:     packet.readFloatLE(12),
       temperature: packet.readFloatLE(16),
       packVoltage: packet.readFloatLE(20),
-      soc:         packet.readFloatLE(24) * 100,
-      soh:         packet.readFloatLE(28) * 100
+      soc:         packet.readFloatLE(24),
+      soh:         packet.readFloatLE(28)
     }
   };
   return result;

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

@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = function Derived(app, sendDeltaCallback, config) {
   app.debug("[DERIVED] Module instantiated with config: " + JSON.stringify(config));
   let voltage, current, ampHourUsed, capacity;
@@ -11,13 +13,29 @@ module.exports = function Derived(app, sendDeltaCallback, config) {
     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 }
+      ];
+
+      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 });
+      } 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 });
+      } else {
+        // fallback when current is 0 or data is abnormal
+        values.push({ path: prefix + 'timeToFull', value: 0 });
+        values.push({ path: prefix + 'timeToEmpty', value: 0 });
+      }
+
       sendDeltaCallback({
-        updates: [{
-          values: [
-            { path: prefix + 'power',             value: power },
-            { path: prefix + 'ampHourRemaining', value: ahRemaining }
-          ]
-        }]
+        updates: [{ values }]
       });
     }
   }
@@ -35,39 +53,115 @@ module.exports = function Derived(app, sendDeltaCallback, config) {
     if (typeof v === 'number') { capacity = v; computeAndSendDeltas(); }
   });
 
+  // ---- Cell diff logic ----
   let totalCells = 0;
-  const cellVoltages = {};
+  let unitsExpected = 0;
+  let cellVoltages = {};
   let subscribedCellStreams = false;
 
+  // prevent duplicate subscriptions if units changes / reconnects
+  const subscribedCells = new Set();
+
+  // retry controls (avoid timer storms + max wait)
+  let pendingCellDiffTimer = null;
+  let firstCellSeenAtMs = null;
+  const CELL_DIFF_RETRY_MS = 200;
+  const CELL_DIFF_MAX_WAIT_MS = 8000;
+
   app.streambundle.getSelfStream(prefix + 'numBMSUnits').forEach(units => {
-    if (!subscribedCellStreams && typeof units === 'number' && units > 0) {
-      totalCells = units * 4;
+    if (typeof units === 'number' && units > 0) {
+      // If units changes (or first time), reset expectations and cached values
+      if (units !== unitsExpected) {
+        unitsExpected = units;
+        totalCells = units * 4;
+        cellVoltages = {};
+        firstCellSeenAtMs = null;
+
+        // clear any pending retry from old expectations
+        if (pendingCellDiffTimer) {
+          clearTimeout(pendingCellDiffTimer);
+          pendingCellDiffTimer = null;
+        }
+      }
+
+      // Ensure we have subscriptions for 1..totalCells (do not duplicate)
       for (let i = 1; i <= totalCells; i++) {
+        if (subscribedCells.has(i)) continue;
+
+        subscribedCells.add(i);
         const cellPath = prefix + 'cellVoltage' + i;
         app.streambundle.getSelfStream(cellPath).forEach(val => {
-          if (typeof val === 'number') {
+          if (typeof val === 'number' && Number.isFinite(val)) {
+            if (!firstCellSeenAtMs) firstCellSeenAtMs = Date.now();
             cellVoltages[i] = val;
             trySendCellDiff();
           }
         });
       }
+
       subscribedCellStreams = true;
+
+      // Attempt immediately in case we already have cached values after restart
+      trySendCellDiff();
     }
   });
 
+  function scheduleCellDiffRetry() {
+    if (pendingCellDiffTimer) return;
+    if (!subscribedCellStreams || totalCells <= 0) return;
+
+    pendingCellDiffTimer = setTimeout(() => {
+      pendingCellDiffTimer = null;
+      trySendCellDiff();
+    }, CELL_DIFF_RETRY_MS);
+  }
+
   function trySendCellDiff() {
-    const keys = Object.keys(cellVoltages).map(k => parseInt(k,10));
-    if (keys.length === totalCells) {
-      const vals = keys.map(i => cellVoltages[i]);
-      const minV = Math.min(...vals);
-      const maxV = Math.max(...vals);
-      sendDeltaCallback({
-        updates: [{
-          values: [
-            { path: prefix + 'cellVoltageDifference', value: maxV - minV }
-          ]
-        }]
-      });
+    if (!subscribedCellStreams || totalCells <= 0) return;
+
+    // Only consider cells within expected range
+    const keys = Object.keys(cellVoltages)
+      .map(k => parseInt(k, 10))
+      .filter(i => Number.isInteger(i) && i >= 1 && i <= totalCells);
+
+    // A: publish as soon as we have enough to compute (>= 2 cells)
+    if (keys.length >= 2) {
+      const vals = keys.map(i => cellVoltages[i]).filter(v => typeof v === 'number' && Number.isFinite(v));
+      if (vals.length >= 2) {
+        const minV = Math.min(...vals);
+        const maxV = Math.max(...vals);
+
+        sendDeltaCallback({
+          updates: [{
+            values: [
+              { path: prefix + 'cellVoltageDifference', value: maxV - minV }
+            ]
+          }]
+        });
+      }
+    }
+
+    // B: if we haven't seen all cells yet, retry safely with max-wait
+    if (keys.length < totalCells) {
+      const now = Date.now();
+      if (!firstCellSeenAtMs) firstCellSeenAtMs = now;
+
+      const elapsed = now - firstCellSeenAtMs;
+      if (elapsed < CELL_DIFF_MAX_WAIT_MS) {
+        scheduleCellDiffRetry();
+      } else {
+        // stop retrying after max wait; cell updates will still trigger publishes
+        if (pendingCellDiffTimer) {
+          clearTimeout(pendingCellDiffTimer);
+          pendingCellDiffTimer = null;
+        }
+      }
+    } else {
+      // all cells present: no need to keep retry timer
+      if (pendingCellDiffTimer) {
+        clearTimeout(pendingCellDiffTimer);
+        pendingCellDiffTimer = null;
+      }
     }
   }
 

package/plugin/lib/websocket/derived.js

@@ -0,0 +1,78 @@
+"use strict";
+
+// Cache latest values across messages
+let latestMaster = null;
+let latestSettings = null;
+
+module.exports = function(parsedData, prefix) {
+  const values = [];
+
+  // Update cache if master data is present
+  if (parsedData?.bms_array?.master) {
+    latestMaster = parsedData.bms_array.master;
+  }
+
+  // Update cache if settings data is present
+  if (parsedData?.type === "settings") {
+    latestSettings = parsedData;
+  }
+
+  // If we don't have both yet, don't compute anything
+  if (!latestMaster || !latestSettings) return values;
+
+  const master = latestMaster;
+  const settings = latestSettings;
+
+  // power = voltage * current
+  if (typeof master.vbat === "number" && typeof master.ibat === "number") {
+    values.push({
+      path: `${prefix}.power`,
+      value: master.vbat * master.ibat
+    });
+  }
+
+  // cellVoltageDifference = max - min
+  if (typeof master.maxcell === "number" && typeof master.mincell === "number") {
+    values.push({
+      path: `${prefix}.cellVoltageDifference`,
+      value: master.maxcell - master.mincell
+    });
+  }
+
+  // ampHourRemaining = capacity - ampHourUsed
+  if (typeof settings.capa === "number" && typeof settings.Ah === "number") {
+    values.push({
+      path: `${prefix}.ampHourRemaining`,
+      value: settings.capa - settings.Ah
+    });
+  }
+
+  // timeToFull / timeToEmpty in seconds
+  if (
+    typeof settings.capa === "number" &&
+    typeof settings.Ah === "number" &&
+    typeof master.ibat === "number"
+  ) {
+    const capacity = settings.capa;
+    const current = master.ibat;
+    const soc = typeof master.soc === "number" ? master.soc : null;
+    const remainingAh = (soc !== null) ? (soc / 100) * capacity : (capacity - settings.Ah);
+
+    if (current > 0 && remainingAh < capacity) {
+      const missingAh = capacity - remainingAh;
+      const timeToFull = (missingAh / current) * 3600;
+      values.push({ path: `${prefix}.timeToFull`, value: timeToFull });
+      values.push({ path: `${prefix}.timeToEmpty`, value: 0 });
+    } else if (current < 0 && remainingAh > 0) {
+      const timeToEmpty = (remainingAh / Math.abs(current)) * 3600;
+      values.push({ path: `${prefix}.timeToFull`, value: 0 });
+      values.push({ path: `${prefix}.timeToEmpty`, value: timeToEmpty });
+    } else {
+      // idle or insufficient current
+      values.push({ path: `${prefix}.timeToFull`, value: 0 });
+      values.push({ path: `${prefix}.timeToEmpty`, value: 0 });
+    }
+  }
+
+  return values;
+};

package/plugin/lib/websocket/settings.js

@@ -8,11 +8,6 @@ module.exports = function(parsedData, prefix, config) {
   const settings = parsedData;
   const values = []; 
 
-  // Derived data - NOT FROM BMS
-  const AhR = (parsedData.capa !== undefined && parsedData.Ah !== undefined)
-    ? parsedData.capa - parsedData.Ah
-    : null;
-  values.push({ path: `${prefix}.ampHourRemaining`, value: AhR });
   // Data from WiFi module WebSocket under SETTINGS message 
   values.push({ path: `${prefix}.address`, value: parsedData.addr });
   values.push({ path: `${prefix}.ampHourUsed`, value: parsedData.Ah });

package/plugin/lib/websocket/status.js

@@ -23,15 +23,10 @@ module.exports = function(parsedData, prefix, config) {
     return null;
   }
 
-  // Derived data - NOT FROM BMS
-  const power = (master.vbat !== undefined && master.ibat !== undefined)
-    ? master.vbat * master.ibat
-    : null;
-  values.push({ path: `${prefix}.power`, value: power });
   // Data from WiFi module WebSocket under SETTINGS message 
   values.push({ path: `${prefix}.date`, value: master.date });
   values.push({ path: `${prefix}.time`, value: master.time });
-  values.push({ path: `${prefix}.cellVoltageDifference`, value: master.maxcell - master.mincell });
+  //values.push({ path: `${prefix}.cellVoltageDifference`, value: master.maxcell - master.mincell });
   values.push({ path: `${prefix}.current`, value: master.ibat });
   values.push({ path: `${prefix}.errorAddress`, value: master.erro.addr });
   values.push({ path: `${prefix}.errorConnectionState`, value: master.erro.con_st });
@@ -42,7 +37,7 @@ module.exports = function(parsedData, prefix, config) {
   values.push({ path: `${prefix}.minCellVoltage`, value: master.mincell });
   values.push({ path: `${prefix}.stateOfCharge`, value: master.soc });
   values.push({ path: `${prefix}.stateOfHealth`, value: master.soh });
-  values.push({ path: `${prefix}.timeRemaining`, value: extractMinutes(master.time_remaining) });
+  //values.push({ path: `${prefix}.timeRemaining`, value: extractMinutes(master.time_remaining) });
   values.push({ path: `${prefix}.voltage`, value: master.vbat });
   values.push({ path: `${prefix}.bmsTemperature`, value: slave.temp_bms });
   values.push({ path: `${prefix}.slaveAddress`, value: slave.address });

package/plugin/lib/websocket/ws.js

@@ -2,6 +2,7 @@
 const WebSocket = require('ws');
 const status = require('./status');
 const settings = require('./settings');
+const derived = require('./derived');
 const schema = require('../schema');
 
 module.exports = function(app, publishDelta) {
@@ -84,6 +85,11 @@ module.exports = function(app, publishDelta) {
           }
         }
 
+        // Add derived values
+        const derivedValues = derived(parsedData, prefix) || [];
+        delta.updates[0].values.push(...derivedValues);
+
+        // Filter out null/undefined
         delta.updates[0].values = delta.updates[0].values.filter(item => item.value !== null && item.value !== undefined);
 
         if (delta.updates[0].values.length > 0) {
@@ -111,9 +117,8 @@ module.exports = function(app, publishDelta) {
     });
 
     ws.on('error', (error) => {
-      app.error(`[WEBSOCKET] WebSocket error: ${error.message}`);
       app.setPluginStatus(`Error: ${error.message} - ERROR`);
-      app.debug("[WEBSOCKET] WebSocket error occurred, terminating connection.");
+      app.debug(`[WEBSOCKET] WebSocket error: "${error.message}", terminating connection.`);
       clearInterval(pingInterval);
       if (ws) ws.terminate();
       if (shouldReconnect) {

package/public/js/main.js

@@ -15,6 +15,7 @@ class BMSSystem {
       current: null,
       power: null,
       stateOfCharge: null,
+      stateOfHealth: null,
       cellVoltages: {},
       cellResistances: {},
       cellVoltageDifference: null,
@@ -38,15 +39,15 @@ class BMSSystem {
 
   cacheDomElements() {
     const metrics = [
-      'voltage', 'current', 'power', 'stateOfCharge', 'cellVoltageDifference',
-      'bmsTemperature', 'cellTemperature1', 'maxCellVoltage', 'minCellVoltage',
-      'ampHourRemaining', 'ampHourUsed', 'capacity'
+      '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.error(`Missing metric element: ${metric}`);
+        console.warn(`Missing metric element: ${metric}`);
       }
     });
   }
@@ -54,7 +55,7 @@ class BMSSystem {
   setupTabSwitching() {
     const statusTab = document.getElementById('nav-status');
     const settingsTab = document.getElementById('nav-settings');
-    
+
     if (!statusTab || !settingsTab) {
       console.warn("Tab elements not found");
       return;
@@ -68,7 +69,7 @@ class BMSSystem {
   switchView(view) {
     const statusView = document.getElementById('status-view');
     const settingsView = document.getElementById('settings-view');
-    
+
     if (view === 'status') {
       statusView?.classList.add('active');
       settingsView?.classList.remove('active');
@@ -90,11 +91,23 @@ class BMSSystem {
     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, "%");
+
+    setValue(
+      this.dom.metricElements.stateOfCharge,
+      this.liveData.stateOfCharge !== null ? this.liveData.stateOfCharge * 100 : null,
+      "%"
+    );
+    setValue(
+      this.dom.metricElements.stateOfHealth,
+      this.liveData.stateOfHealth !== null ? this.liveData.stateOfHealth * 100 : null,
+      "%"
+    );
+
     if (this.dom.metricElements.cellVoltageDifference) {
       const v = this.liveData.cellVoltageDifference;
       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");
@@ -106,20 +119,23 @@ class BMSSystem {
 
   connectWebSocket() {
     try {
-      const ws = new WebSocket(`ws://${window.location.host}/signalk/v1/stream?subscribe=self&path=electrical.batteries.bms.*`);
-
+      const wsScheme = (window.location.protocol === "https:") ? "wss" : "ws";
+      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;
@@ -130,7 +146,7 @@ class BMSSystem {
             }
           });
         });
-
+  
         this.updateMetrics();
         CellVisualizer.updateAllCells({
           cellVoltages: this.liveData.cellVoltages,
@@ -140,7 +156,7 @@ class BMSSystem {
     } catch (error) {
       console.error("WebSocket initialization failed:", error);
     }
-  }
+  }  
 }
 
 document.addEventListener('DOMContentLoaded', () => {