signalk-rec-bms 1.1.6 → 2.0.0

package/README.md

@@ -4,19 +4,19 @@
 
 ## Features
 
-- Reads all avabile data streams from BMS and publishes to SignalK
-- Supports Websocket connection from the REC WiFi module with firmare >= SW164_2
+- Reads all available data streams from BMS and publishes to SignalK
+- Supports WebSocket connection from the REC WiFi module with firmware >= SW164_2
 - Supports serial connection directly from BMS
 - Can set BMS settings when using serial connection
-- Live status & settings page within SignalK 
+- Live status & settings page within SignalK
 
 ## Notes
 
-Tested with the 4 cell ABMS model only
+Tested with the 4 cell ABMS model only. Multi-unit series configurations are detected automatically but have not been tested beyond a single unit — proceed with caution if running multiple ABMS units in series.
 
 ## Requirements
 
-#### Websocket connection (WiFi):
+#### WebSocket connection (WiFi):
 
 - A REC WiFi module with firmware >= SW164_2, which enables websockets  
 
@@ -32,7 +32,7 @@ Tested with the 4 cell ABMS model only
 
 ## Dependencies
 
-- npm package: [websocket](https://www.npmjs.com/package/websocket)
+- npm package: [ws](https://www.npmjs.com/package/ws)
 - npm package: [serialport](https://www.npmjs.com/package/serialport)
 - npm package: [crc](https://www.npmjs.com/package/crc)
 
@@ -45,14 +45,36 @@ Run the following command:
    npm install signalk-rec-bms
    ```
 
+## SignalK Paths
+
+All data is published under `electrical.batteries.bms.*` by default. The base path is configurable via the `deltaPrefix` plugin setting. Key paths include:
+
+| Path | Description |
+|---|---|
+| `electrical.batteries.bms.voltage` | Pack voltage |
+| `electrical.batteries.bms.current` | Pack current |
+| `electrical.batteries.bms.power` | Instantaneous power |
+| `electrical.batteries.bms.capacity.stateOfCharge` | State of charge (0–1) |
+| `electrical.batteries.bms.capacity.stateOfHealth` | State of health (0–1) |
+| `electrical.batteries.bms.capacity.nominal` | Configured capacity (Ah) |
+| `electrical.batteries.bms.capacity.remaining` | Estimated remaining (Ah) |
+| `electrical.batteries.bms.cellVoltage{N}` | Individual cell voltages |
+| `electrical.batteries.bms.cellTemperature{N}` | Cell temperatures (K) |
+| `electrical.batteries.bms.cellResistance{N}` | Cell internal resistance (Ohm) |
+| `electrical.batteries.bms.bmsTemperature` | BMS board temperature (K) |
+| `electrical.batteries.bms.minCellVoltage` | Minimum cell voltage |
+| `electrical.batteries.bms.maxCellVoltage` | Maximum cell voltage |
+
+Temperature values are published in Kelvin in compliance with the SignalK specification. Instrument displays that respect SK unit preferences will convert automatically to °C or °F.
+
 ## Victron Cerbo GX / Venus OS
 
-VenusOS claims all serial devices by default and attempts to pair them with a pre-defined service. This script works by telling VenusOS to ignore your usb to serial device & allowing you to use it with SignalK. 
+VenusOS claims all USB serial devices by default via its `serial-starter` service, which cycles through Victron protocols and prevents SignalK from accessing the port. The setup script creates a udev rule that instructs VenusOS to ignore your specific RS485 adapter, leaving it available exclusively for SignalK. The rule uses a `zz-` prefix to ensure it overrides Victron's default rules regardless of load order.
 
 ```bash
 curl -o /home/root/signalk-rec-bms-venusOS.sh https://raw.githubusercontent.com/ofernander/signalk-rec-bms/main/venus-os/signalk-rec-bms-venusOS.sh && bash /home/root/signalk-rec-bms-venusOS.sh
 ```
 
-The script will list your connected USB serial devices, you select which one is the usb to serial converter for your REC-BMS. Once complete, unplug and replug your RS485 adapter, then reboot the Cerbo device. 
+The script will list your connected USB serial devices, you select which one is the usb to serial converter for your REC-BMS. Once complete, unplug and replug your RS485 adapter, then reboot the Cerbo device.
 
-To uninstall: `bash /home/root/signalk-rec-bms-venusOS.sh --uninstall` or select the last option in the script menu. 
+To uninstall: `bash /home/root/signalk-rec-bms-venusOS.sh --uninstall` or select the last option in the script menu.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-rec-bms",
-  "version": "1.1.6",
+  "version": "2.0.0",
   "description": "SignalK plugin for REC-BMS",
   "main": "plugin/index.js",
   "scripts": {
@@ -29,7 +29,7 @@
     "node": ">=10"
   },
   "signalk": {
-    "appIcon": "./assets/icons/rec_ball-72x72.png",
+    "appIcon": "./assets/icons/signalk-rec-bms-icon_72x72.png",
     "displayName": "SignalK-REC-BMS"
   }
 }

package/plugin/index.js

@@ -2,37 +2,115 @@
 
 const schema = require('./lib/schema');
 const connection = require('./lib/connection');
+const HistoryBuffer = require('./lib/history');
 
 module.exports = function(app) {
   let conn;
   let pluginOptions;
-  let commsHandler;
+  let historyBuffer;
+  let historyRouteRegistered = false;
+
+  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);
-      }
-    }
-  
+    if (historyBuffer) historyBuffer.record(delta);
+
     const precision = 5;
     const factor = Math.pow(10, precision);
-  
+
     delta.updates.forEach(update => {
+      update.$source = "signalk-rec-bms";
       update.values.forEach(item => {
         if (typeof item.value === "number") {
           item.value = Math.round(item.value * factor) / factor;
         }
       });
     });
-  
+
     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 +118,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,18 +128,35 @@ module.exports = function(app) {
       pluginOptions = options;
       app.debug(`[INDEX] START invoked with options: ${JSON.stringify(options)}`);
       app.setPluginStatus("Connecting to BMS…");
+
+      const prefix = options.deltaPrefix || "electrical.batteries.bms";
+      const dataDir = typeof app.getDataDirPath === 'function' ? app.getDataDirPath() : null;
+      historyBuffer = new HistoryBuffer(prefix, dataDir);
+
+      if (!historyRouteRegistered) {
+        historyRouteRegistered = true;
+        app.get('/signalk/v1/bms/history', (req, res) => {
+          if (!historyBuffer) return res.status(503).json({ error: "Buffer not ready" });
+          const hours = req.query.hours || 1;
+          res.json(historyBuffer.getHistory(hours));
+        });
+      }
+
+      publishMeta(options);
       conn = connection(options, app, publishDelta);
       conn.start(options);
     },
     stop: function() {
+      if (historyBuffer) historyBuffer.stop();
       if (conn) {
         conn.stop();
         conn = null;
       }
+      historyBuffer = null;
       app.debug("[INDEX] Plugin stopped");
       app.setPluginStatus("Stopped");
     },
   };
 
   return plugin;
-};
+};

package/plugin/lib/history.js

@@ -0,0 +1,163 @@
+"use strict";
+
+const fs = require('fs');
+const path = require('path');
+
+const FLUSH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+module.exports = function HistoryBuffer(prefix, dataDir) {
+  const persistPath = dataDir
+    ? path.join(dataDir, 'bms-history.json')
+    : null;
+
+  // Three-tier storage per metric
+  // Each entry: { t: timestamp_ms, v: value }
+  const store = {
+    voltage: { fine: [], medium: [], coarse: [] },
+    current: { fine: [], medium: [], coarse: [] },
+    power:   { fine: [], medium: [], coarse: [] },
+    soc:     { fine: [], medium: [], coarse: [] }
+  };
+
+  // Tier boundaries and max retention
+  const FINE_RESOLUTION_MS   = 10 * 1000;       // 10s — keep for 1 hour
+  const MEDIUM_RESOLUTION_MS = 60 * 1000;       // 1m  — keep for 6 hours
+  const COARSE_RESOLUTION_MS = 5 * 60 * 1000;   // 5m  — keep for 24 hours
+
+  const FINE_MAX_AGE_MS   = 1 * 60 * 60 * 1000;   // 1 hour
+  const MEDIUM_MAX_AGE_MS = 6 * 60 * 60 * 1000;   // 6 hours
+  const COARSE_MAX_AGE_MS = 24 * 60 * 60 * 1000;  // 24 hours
+
+  // Last recorded timestamp per metric per tier, for resolution gating
+  const lastRecorded = {
+    voltage: { fine: 0, medium: 0, coarse: 0 },
+    current: { fine: 0, medium: 0, coarse: 0 },
+    power:   { fine: 0, medium: 0, coarse: 0 },
+    soc:     { fine: 0, medium: 0, coarse: 0 }
+  };
+
+  // Load persisted data on startup
+  if (persistPath) {
+    try {
+      const raw = fs.readFileSync(persistPath, 'utf8');
+      const saved = JSON.parse(raw);
+      const now = Date.now();
+
+      for (const metric of ['voltage', 'current', 'power', 'soc']) {
+        if (saved[metric]) {
+          store[metric].fine   = (saved[metric].fine   || []).filter(p => p.t >= now - FINE_MAX_AGE_MS);
+          store[metric].medium = (saved[metric].medium || []).filter(p => p.t >= now - MEDIUM_MAX_AGE_MS);
+          store[metric].coarse = (saved[metric].coarse || []).filter(p => p.t >= now - COARSE_MAX_AGE_MS);
+        }
+      }
+
+      // Restore lastRecorded from last entry in each tier so we don't duplicate points
+      for (const metric of ['voltage', 'current', 'power', 'soc']) {
+        for (const tier of ['fine', 'medium', 'coarse']) {
+          const arr = store[metric][tier];
+          if (arr.length > 0) lastRecorded[metric][tier] = arr[arr.length - 1].t;
+        }
+      }
+    } catch (e) {
+      // Missing or corrupt file — start fresh silently
+    }
+  }
+
+  const pathMap = {
+    [`${prefix}.voltage`]:                'voltage',
+    [`${prefix}.current`]:                'current',
+    [`${prefix}.power`]:                  'power',
+    [`${prefix}.capacity.stateOfCharge`]: 'soc'
+  };
+
+  function record(delta) {
+    if (!delta.updates) return;
+    const now = Date.now();
+
+    delta.updates.forEach(update => {
+      if (!update.values) return;
+      update.values.forEach(({ path, value }) => {
+        const metric = pathMap[path];
+        if (!metric || typeof value !== 'number') return;
+        push(metric, now, value);
+      });
+    });
+  }
+
+  function push(metric, now, value) {
+    const tiers = store[metric];
+    const last = lastRecorded[metric];
+
+    if (now - last.fine >= FINE_RESOLUTION_MS) {
+      tiers.fine.push({ t: now, v: value });
+      last.fine = now;
+    }
+
+    if (now - last.medium >= MEDIUM_RESOLUTION_MS) {
+      tiers.medium.push({ t: now, v: value });
+      last.medium = now;
+    }
+
+    if (now - last.coarse >= COARSE_RESOLUTION_MS) {
+      tiers.coarse.push({ t: now, v: value });
+      last.coarse = now;
+    }
+
+    prune(tiers.fine,   now - FINE_MAX_AGE_MS);
+    prune(tiers.medium, now - MEDIUM_MAX_AGE_MS);
+    prune(tiers.coarse, now - COARSE_MAX_AGE_MS);
+  }
+
+  function prune(arr, cutoff) {
+    while (arr.length > 0 && arr[0].t < cutoff) arr.shift();
+  }
+
+  function flush() {
+    if (!persistPath) return;
+    try {
+      const data = {};
+      for (const metric of ['voltage', 'current', 'power', 'soc']) {
+        data[metric] = {
+          fine:   store[metric].fine,
+          medium: store[metric].medium,
+          coarse: store[metric].coarse
+        };
+      }
+      fs.writeFileSync(persistPath, JSON.stringify(data), 'utf8');
+    } catch (e) {
+      // Write failure — non-fatal, will retry on next interval
+    }
+  }
+
+  // Periodic flush to disk
+  let flushTimer = null;
+  if (persistPath) {
+    flushTimer = setInterval(() => flush(), FLUSH_INTERVAL_MS);
+  }
+
+  function getHistory(hours) {
+    const h = Math.min(Math.max(parseFloat(hours) || 1, 0.25), 24);
+    const now = Date.now();
+    const cutoff = now - h * 60 * 60 * 1000;
+
+    let tier;
+    if (h <= 1)       tier = 'fine';
+    else if (h <= 6)  tier = 'medium';
+    else              tier = 'coarse';
+
+    const result = {};
+    for (const metric of ['voltage', 'current', 'power', 'soc']) {
+      result[metric] = store[metric][tier]
+        .filter(p => p.t >= cutoff)
+        .map(p => ({ t: p.t, v: p.v }));
+    }
+    return { hours: h, tier, generated: now, data: result };
+  }
+
+  function stop() {
+    if (flushTimer) clearInterval(flushTimer);
+    flush(); // flush on stop so shutdown data is preserved
+  }
+
+  return { record, getHistory, stop };
+};

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/Layer2.js

@@ -5,8 +5,6 @@ class Layer2 {
 	constructor() {
 		this.buffer = [];
 		this.stats = {
-			tx: 0,
-			txBytes: 0,
 			rx: 0,
 			rxBytes: 0,
 			badCRC: 0
@@ -66,4 +64,4 @@ class Layer2 {
 	}
 }
 
-module.exports = Layer2;
+module.exports = Layer2;

package/plugin/lib/serial/atlas.json

@@ -490,16 +490,6 @@
     "description": "SERI? returns ABMS serial number",
     "module": "abms"
   },
-  {
-    "tag": "SERI2",
-    "command": "SERI?",
-    "expectedPackets": 1,
-    "payloadSizes": [null],
-    "parser": "parseSERIResponse",
-    "timeout": 1000,
-    "description": "SERI2? returns ABMS serial number (hidden duplicate)",
-    "module": "abms"
-  },
   {
     "tag": "SWVR",
     "command": "SWVR?",
@@ -549,5 +539,5 @@
     "timeout": 1000,
     "description": "WCBI? returns balancing cell number",
     "module": "abms"
-  } 
+  }
 ]

package/plugin/lib/serial/engine.js

@@ -1,6 +1,4 @@
 "use strict";
-const fs = require('fs');
-const path = require('path');
 const EventEmitter = require('events');
 const hexer = require('./hexer');
 const atlas = require('./atlas.json');
@@ -18,9 +16,14 @@ class CommandEngine extends EventEmitter {
 
   sendCommand(tag, targetAddress, rawCommandStr = null, options = {}) {
     return new Promise((resolve, reject) => {
+      // If a command is already in flight, reject unless caller explicitly forces
+      if (this.activeCommand && !options.force) {
+        return reject(new Error(`[ENGINE] Busy — command ${this.activeCommand.tag} in flight, dropping ${tag}`));
+      }
+
       let commandStr;
       let expectedPackets = 1;
-      let timeoutMs = 3000; 
+      let timeoutMs = 3000;
       let config = atlasMapping[tag];
 
       if (rawCommandStr) {
@@ -64,6 +67,7 @@ class CommandEngine extends EventEmitter {
         currentCommand.timeout = setTimeout(() => {
           const errMsg = `${tag} response timed out after ${timeoutMs} ms`;
           if (currentCommand && typeof currentCommand.reject === "function") {
+            this.activeCommand = null;
             currentCommand.reject(new Error(errMsg));
           }
         }, timeoutMs);

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
-};
+};