signalk-rec-bms 2.0.2 → 2.1.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "signalk-rec-bms",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "SignalK plugin for REC-BMS",
   "main": "plugin/index.js",
   "scripts": {
-    "test": "node --test test/parsers.test.js"
+    "test": "node --test test/parsers.test.js test/engine.test.js test/serial.test.js test/routes.test.js"
   },
   "keywords": [
     "signalk-webapp",
@@ -26,7 +26,7 @@
     "url": "https://github.com/ofernander/signalk-rec-bms"
   },
   "engines": {
-    "node": ">=10"
+    "node": ">=20"
   },
   "signalk": {
     "appIcon": "./assets/icons/signalk-rec-bms-icon_72x72.png",

package/plugin/index.js

@@ -4,14 +4,15 @@ const schema = require('./lib/schema');
 const connection = require('./lib/connection');
 const HistoryBuffer = require('./lib/history');
 
+const DEFAULT_PREFIX = "electrical.batteries.bms";
+
 module.exports = function(app) {
   let conn;
   let pluginOptions;
   let historyBuffer;
-  let historyRouteRegistered = false;
 
   function publishMeta(options) {
-    const p = options.deltaPrefix || "electrical.batteries.bms";
+    const p = options.deltaPrefix || DEFAULT_PREFIX;
 
     const meta = [
       // Live data
@@ -119,29 +120,67 @@ module.exports = function(app) {
     }
   }
 
+  // When server security is enabled every request reaching a plugin route is
+  // authenticated, but read-only users (including anonymous ones when
+  // allow_readonly is set) get through too. Changing BMS settings requires admin.
+  function isAdmin(req) {
+    const principal = req.skPrincipal;
+    return !principal || principal.permissions === 'admin';
+  }
+
+  // Mounted by the server at /plugins/signalk-rec-bms/
+  function registerWithRouter(router) {
+    // Servers >= 2.33 require admin for plugin routes unless declared via
+    // router.access(); the read-only routes back the dashboard, so any logged
+    // in user may read them. /command is left undeclared (admin only).
+    const readonly = typeof router.access === 'function' ? router.access('readonly') : router;
+
+    readonly.get('/info', (req, res) => {
+      res.json({
+        running: !!conn,
+        deltaPrefix: (pluginOptions && pluginOptions.deltaPrefix) || DEFAULT_PREFIX,
+        connectionType: pluginOptions && pluginOptions.connection && pluginOptions.connection.connectionType
+      });
+    });
+
+    readonly.get('/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));
+    });
+
+    router.post('/command', (req, res) => {
+      const command = req.body && req.body.command;
+      if (!isAdmin(req)) {
+        return res.status(403).json({ error: "Admin permission required to send BMS commands", command });
+      }
+      if (!conn) {
+        return res.status(503).json({ error: "Plugin not running", command });
+      }
+      if (typeof conn.handleCommand !== 'function') {
+        return res.status(400).json({ error: "Commands are only supported on a serial connection", command });
+      }
+      conn.handleCommand(command)
+        .then(result => res.json(result))
+        .catch(err => res.status(err.statusCode || 500).json({ error: err.message, command }));
+    });
+  }
+
   var plugin = {
     id: "signalk-rec-bms",
     name: "SignalK-REC-BMS",
     description: "SignalK plugin for REC-BMS",
     schema: schema,
+    registerWithRouter,
     start: function(options) {
       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 prefix = options.deltaPrefix || DEFAULT_PREFIX;
       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);

package/plugin/lib/serial/engine.js

@@ -7,24 +7,36 @@ atlas.forEach(entry => {
   atlasMapping[entry.tag] = entry;
 });
 
+const DEFAULT_MAX_QUEUE = 20;
+// After a write-only (set) command, hold the bus briefly so any reply the BMS
+// sends is discarded rather than mistaken for the next command's response.
+const DEFAULT_SETTLE_MS = 250;
+
+// Serialises commands onto the RS-485 bus. Only one command is ever in flight;
+// everything else waits in a FIFO queue. Priority commands (manual commands
+// from the UI) jump to the front of the queue but never interrupt the command
+// currently in flight.
 class CommandEngine extends EventEmitter {
-  constructor(port) {
+  constructor(port, options = {}) {
     super();
     this.port = port;
+    this.maxQueue = options.maxQueue || DEFAULT_MAX_QUEUE;
+    this.settleMs = options.settleMs != null ? options.settleMs : DEFAULT_SETTLE_MS;
+    this.queue = [];
     this.activeCommand = null;
+    this.closed = false;
   }
 
   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}`));
+      if (this.closed) {
+        return reject(new Error(`[ENGINE] Closed, dropping ${tag}`));
       }
 
       let commandStr;
       let expectedPackets = 1;
       let timeoutMs = 3000;
-      let config = atlasMapping[tag];
+      const config = atlasMapping[tag];
 
       if (rawCommandStr) {
         commandStr = rawCommandStr;
@@ -37,56 +49,98 @@ class CommandEngine extends EventEmitter {
         timeoutMs = config.timeout;
       }
 
-      const packet = hexer.buildPacket(targetAddress, Buffer.from(commandStr));
+      let packet;
+      try {
+        packet = hexer.buildPacket(targetAddress, Buffer.from(commandStr));
+      } catch (err) {
+        return reject(err);
+      }
 
-      if (options.expectResponse === false) {
-        this.port.write(packet, (err) => {
-          if (err) return reject(err);
-          resolve({ raw: true });
-        });
-        return;
+      if (!options.priority && this.queue.length >= this.maxQueue) {
+        return reject(new Error(`[ENGINE] Queue full, dropping ${tag}`));
       }
 
-      this.activeCommand = {
+      const job = {
         tag,
+        packet,
         expectedPackets,
         timeoutMs,
+        expectResponse: options.expectResponse !== false,
         receivedPackets: [],
+        timeout: null,
         resolve,
-        reject,
-        config
+        reject
       };
 
-      const currentCommand = this.activeCommand;
+      if (options.priority) {
+        this.queue.unshift(job);
+      } else {
+        this.queue.push(job);
+      }
+      this._next();
+    });
+  }
 
-      this.port.write(packet, (err) => {
-        if (err) {
-          this.activeCommand = null;
-          return reject(err);
-        }
-        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);
-      });
+  _next() {
+    if (this.closed || this.activeCommand || this.queue.length === 0) return;
+
+    const job = this.queue.shift();
+    this.activeCommand = job;
+
+    this.port.write(job.packet, (err) => {
+      // The command may have been cancelled by close() while the write was pending
+      if (this.activeCommand !== job) return;
+
+      if (err) {
+        this._finish(job);
+        return job.reject(err);
+      }
+
+      if (!job.expectResponse) {
+        job.resolve({ raw: true });
+        job.timeout = setTimeout(() => this._finish(job), this.settleMs);
+        return;
+      }
+
+      job.timeout = setTimeout(() => {
+        if (this.activeCommand !== job) return;
+        this._finish(job);
+        job.reject(new Error(`${job.tag} response timed out after ${job.timeoutMs} ms`));
+      }, job.timeoutMs);
     });
   }
 
+  // Clear the active slot and move on to the next queued command
+  _finish(job) {
+    clearTimeout(job.timeout);
+    if (this.activeCommand === job) this.activeCommand = null;
+    setImmediate(() => this._next());
+  }
+
   processPacket(packet) {
-    if (!this.activeCommand) {
+    const job = this.activeCommand;
+    if (!job || !job.expectResponse) {
       this.emit('unhandledPacket', packet);
       return;
     }
-    this.activeCommand.receivedPackets.push(packet);
-    if (this.activeCommand.receivedPackets.length === this.activeCommand.expectedPackets) {
+    job.receivedPackets.push(packet);
+    if (job.receivedPackets.length === job.expectedPackets) {
+      this._finish(job);
+      job.resolve(job.receivedPackets);
+    }
+  }
+
+  // Reject everything in flight and queued; the engine cannot be reused afterwards
+  close() {
+    this.closed = true;
+    const err = new Error('[ENGINE] Closed');
+    const pending = this.queue.splice(0);
+    if (this.activeCommand) {
       clearTimeout(this.activeCommand.timeout);
-      const packets = this.activeCommand.receivedPackets;
-      this.activeCommand.resolve(packets);
+      pending.unshift(this.activeCommand);
       this.activeCommand = null;
     }
+    pending.forEach(job => job.reject(err));
   }
 }
 

package/plugin/lib/serial/serial.js

@@ -28,146 +28,220 @@ const moduleMapping = {
   abms: abmsModule
 };
 
-module.exports = function(app, publishDelta) {
-  let port, parser, engine;
-  let derivedModule;
-  let pollingInterval;
-  let routeRegistered = false;
-
-  function start(options) {
-    app.debug("[SERIAL] start() called with options: " + JSON.stringify(options));
-    port = new SerialPort({
-      path: options.serial.device,
-      baudRate: options.serial.baudRate,
-      dataBits: 8,
-      stopBits: 1,
-      parity: 'none'
-    });
+// Minimum spacing between poll commands (start to start). Polls run one at a
+// time, so a slow or timed-out command delays the next one instead of
+// causing it to be skipped.
+const POLL_SPACING_MS = 100;
+const INITIAL_RECONNECT_MS = 5000;
+const MAX_RECONNECT_MS = 60000;
+// Consecutive failed polls before the port is considered open but the BMS silent
+const NO_RESPONSE_THRESHOLD = 20;
+
+const pollList = atlas.filter(entry => entry.module && moduleMapping[entry.module]);
+
+// deps.SerialPort lets tests substitute a fake port
+module.exports = function(app, publishDelta, deps = {}) {
+  const SerialPortClass = deps.SerialPort || SerialPort;
+
+  let options;
+  let port = null;
+  let engine = null;
+  let derivedModule = null;
+  let stopped = true;
+  let reconnectTimer = null;
+  let reconnectDelay = INITIAL_RECONNECT_MS;
+  let pollTimer = null;
+  let polling = false;
+  let consecutiveFailures = 0;
+  let connectedStatus = "Connected to BMS - Connection Type: Serial";
+
+  function setError(msg) {
+    if (typeof app.setPluginError === 'function') app.setPluginError(msg);
+    else app.setPluginStatus(msg + " - ERROR");
+  }
 
-    engine = new CommandEngine(port);
-    parser = new Layer2();
+  function startPolling() {
+    polling = true;
+    consecutiveFailures = 0;
+    let currentIndex = 0;
 
-    port.on('data', (data) => parser.push(data));
-    parser.on('data', (packet) => engine.processPacket(packet));
+    const pollNext = () => {
+      if (!polling) return;
+      const config = pollList[currentIndex];
+      currentIndex = (currentIndex + 1) % pollList.length;
+      const commandModule = moduleMapping[config.module];
+      const startedAt = Date.now();
 
-    port.on('open', () => {
-      app.setPluginStatus("Connected to BMS - Connection Type: Serial");
-      engine.sendCommand('SERI', options.serial.targetAddress)
+      engine.sendCommand(config.tag, options.serial.targetAddress)
         .then(packets => {
-          const parsed = abmsModule.parseSERIResponse(packets);
-          if (parsed && parsed.data && parsed.data.abmsSerialNumber != null) {
-            const sn = parsed.data.abmsSerialNumber;
-            app.setPluginStatus(
-              `Connected to BMS ${sn} - Connection Type: Serial`
-            );
+          if (consecutiveFailures >= NO_RESPONSE_THRESHOLD) app.setPluginStatus(connectedStatus);
+          consecutiveFailures = 0;
+          const parsed = commandModule[config.parser]?.(packets);
+          if (parsed) {
+            const moduleDelta = commandModule.getDelta(parsed, options, app);
+            if (moduleDelta) publishDelta(moduleDelta);
           }
         })
         .catch(err => {
-          app.debug("[SERIAL] Failed to read serial number: " + err.message);
+          if (!polling) return;
+          app.debug("[SERIAL] " + config.tag + " error: " + err.message);
+          consecutiveFailures++;
+          if (consecutiveFailures === NO_RESPONSE_THRESHOLD) {
+            setError("Serial port open but no response from BMS - check wiring and 3V supply");
+          }
+        })
+        .finally(() => {
+          if (!polling) return;
+          const wait = Math.max(0, POLL_SPACING_MS - (Date.now() - startedAt));
+          pollTimer = setTimeout(pollNext, wait);
         });
+    };
 
-      derivedModule = derived(app, publishDelta, { deltaPrefix: options.deltaPrefix });
-
-      const commandList = atlas.map(entry => entry.tag);
-      let currentIndex = 0;
-
-      pollingInterval = setInterval(() => {
-        const tag = commandList[currentIndex];
-        currentIndex = (currentIndex + 1) % commandList.length;
-
-        const config = atlas.find(entry => entry.tag === tag);
-        if (!config || !config.module || !moduleMapping[config.module]) return;
-
-        const commandModule = moduleMapping[config.module];
-
-        engine.sendCommand(tag, options.serial.targetAddress)
-          .then(packets => {
-            const parsed = commandModule[config.parser]?.(packets);
-            if (parsed) {
-              const moduleDelta = commandModule.getDelta(parsed, options, app);
-              if (moduleDelta) publishDelta(moduleDelta);
-            }
-          })
-          .catch(err => {
-            if (err.message.startsWith('[ENGINE] Busy')) {
-              app.debug("[SERIAL] Skipping " + tag + " — engine busy");
-            } else {
-              app.debug("[SERIAL] Error: " + err.message);
-            }
-          });
-      }, 100);
-
-      if (!routeRegistered) {
-        routeRegistered = true;
-        app.post('/signalk/v1/bms/command', (req, res) => {
-          const { command } = req.body;
-          if (!command) return res.status(400).json({ error: "Missing command" });
-
-          const parts = command.trim().split(/\s+/);
-          let tag = parts[0];
-          const raw = command.trim();
-          const isQuery = tag.endsWith("?");
-
-          if (isQuery) {
-            tag = tag.slice(0, -1);
-          }
+    pollNext();
+  }
 
-          const config = atlas.find(entry => entry.tag === tag);
-
-          if (config && config.module && moduleMapping[config.module]) {
-            const commandModule = moduleMapping[config.module];
-            const expectResponse = isQuery;
-
-            engine.sendCommand(tag, options.serial.targetAddress, raw, { expectResponse, force: true })
-              .then(packets => {
-                if (expectResponse) {
-                  const parsed = commandModule[config.parser]?.(packets);
-                  res.json({
-                    command,
-                    response: parsed,
-                    rawPackets: packets.map(p => p.toString('hex'))
-                  });
-                } else {
-                  res.json({
-                    command,
-                    response: { status: "sent (no response expected)" }
-                  });
-                }
-              })
-              .catch(err => {
-                res.status(500).json({ error: err.message, command });
-              });
-          } else {
-            res.status(400).json({ error: "Unknown or unsupported command" });
-          }
-        });
-      }
+  function stopPolling() {
+    polling = false;
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+
+  function readSerialNumber() {
+    engine.sendCommand('SERI', options.serial.targetAddress)
+      .then(packets => {
+        const parsed = abmsModule.parseSERIResponse(packets);
+        if (parsed && parsed.data && parsed.data.abmsSerialNumber != null) {
+          connectedStatus = `Connected to BMS ${parsed.data.abmsSerialNumber} - Connection Type: Serial`;
+          app.setPluginStatus(connectedStatus);
+        }
+      })
+      .catch(err => app.debug("[SERIAL] Failed to read serial number: " + err.message));
+  }
+
+  function openPort() {
+    app.debug(`[SERIAL] Opening ${options.serial.device}`);
+    const p = new SerialPortClass({
+      path: options.serial.device,
+      baudRate: options.serial.baudRate,
+      dataBits: 8,
+      stopBits: 1,
+      parity: 'none',
+      autoOpen: false
+    });
+    const eng = new CommandEngine(p);
+    const parser = new Layer2();
+    port = p;
+    engine = eng;
+
+    p.on('data', (data) => parser.push(data));
+    parser.on('data', (packet) => eng.processPacket(packet));
+
+    p.on('open', () => {
+      if (port !== p) return;
+      app.debug("[SERIAL] Port open");
+      reconnectDelay = INITIAL_RECONNECT_MS;
+      app.setPluginStatus(connectedStatus);
+      readSerialNumber();
+      startPolling();
     });
 
-    port.on('error', (err) => app.debug("[SERIAL] Error: " + err.message));
+    // Fires on USB unplug (err.disconnected) as well as on a normal close
+    p.on('close', (err) => {
+      if (port !== p) return;
+      handleDisconnect(err ? err.message : "port closed");
+    });
+
+    p.on('error', (err) => app.debug("[SERIAL] Error: " + err.message));
+
+    p.open((err) => {
+      if (err && port === p) handleDisconnect(err.message);
+    });
+  }
+
+  function teardownPort() {
+    stopPolling();
+    if (engine) engine.close();
+    const p = port;
+    port = null;
+    engine = null;
+    if (p) {
+      p.removeAllListeners();
+      p.on('error', () => {}); // a late error with no listener would throw
+      if (p.isOpen) p.close(() => {});
+    }
+  }
+
+  function handleDisconnect(reason) {
+    teardownPort();
+    if (stopped || reconnectTimer) return;
+    const delay = reconnectDelay;
+    setError(`BMS serial disconnected (${reason}) - retrying in ${Math.round(delay / 1000)}s`);
+    app.debug(`[SERIAL] Disconnected: ${reason}. Reconnecting in ${delay} ms`);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      if (!stopped) openPort();
+    }, delay);
+    reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_MS);
+  }
+
+  function start(opts) {
+    app.debug("[SERIAL] start() called with options: " + JSON.stringify(opts));
+    options = opts;
+    stopped = false;
+    reconnectDelay = INITIAL_RECONNECT_MS;
+    derivedModule = derived(app, publishDelta, { deltaPrefix: options.deltaPrefix });
+    openPort();
   }
 
   function stop() {
-    clearInterval(pollingInterval);
-    if (port) port.close();
+    stopped = true;
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+    teardownPort();
     if (derivedModule && typeof derivedModule.stop === 'function') derivedModule.stop();
+    derivedModule = null;
+  }
+
+  // Run a manual command from the UI, e.g. "CHAR?" (query) or "CHAR 3.55" (set).
+  // Resolves to a JSON-serialisable result; rejects with err.statusCode set for
+  // client errors.
+  function handleCommand(command) {
+    const clientError = (msg, statusCode = 400) => Object.assign(new Error(msg), { statusCode });
+
+    if (typeof command !== 'string' || !command.trim()) {
+      return Promise.reject(clientError("Missing command"));
+    }
+    if (!engine) {
+      return Promise.reject(clientError("BMS serial port not connected", 503));
+    }
+
+    const raw = command.trim();
+    let tag = raw.split(/\s+/)[0];
+    const isQuery = tag.endsWith("?");
+    if (isQuery) tag = tag.slice(0, -1);
+
+    const config = atlas.find(entry => entry.tag === tag);
+    if (!config || !config.module || !moduleMapping[config.module]) {
+      return Promise.reject(clientError("Unknown or unsupported command"));
+    }
+    const commandModule = moduleMapping[config.module];
+
+    return engine.sendCommand(tag, options.serial.targetAddress, raw, { expectResponse: isQuery, priority: true })
+      .then(packets => {
+        if (!isQuery) {
+          return { command, response: { status: "sent (no response expected)" } };
+        }
+        return {
+          command,
+          response: commandModule[config.parser]?.(packets),
+          rawPackets: packets.map(p => p.toString('hex'))
+        };
+      });
   }
 
   return {
     start,
     stop,
-    schema: require('../schema'),
-    sendManualCommand: (tag, targetAddress) => {
-      const config = atlas.find(entry => entry.tag === tag);
-      if (!config || !config.module || !moduleMapping[config.module]) {
-        throw new Error("Unknown or unsupported command");
-      }
-      const commandModule = moduleMapping[config.module];
-      return engine.sendCommand(tag, targetAddress, null, { force: true })
-        .then(packets => ({
-          packets,
-          parsed: commandModule[config.parser]?.(packets)
-        }));
-    }
+    handleCommand
   };
 };

package/public/js/chart.js

@@ -141,7 +141,7 @@ class BMSChart {
 
   async fetch() {
     try {
-      const res = await fetch(`/signalk/v1/bms/history?hours=${this.activeHours}`);
+      const res = await fetch(`${PLUGIN_API}/history?hours=${this.activeHours}`);
       if (!res.ok) return;
       const json = await res.json();
       this._update(json);

package/public/js/main.js

@@ -1,8 +1,12 @@
 'use strict';
 
+const PLUGIN_API = '/plugins/signalk-rec-bms';
+const DEFAULT_PREFIX = 'electrical.batteries.bms';
+
 class BMSMonitor {
   constructor() {
-    this.prefix = 'electrical.batteries.bms.';
+    this.deltaPrefix = DEFAULT_PREFIX;
+    this.prefix = DEFAULT_PREFIX + '.';
     this.ws = null;
     this.reconnectDelay = 5000;
     this.reconnectTimer = null;
@@ -31,16 +35,34 @@ class BMSMonitor {
     };
   }
 
-  init() {
+  async init() {
     this._initNightMode();
     this._initTabs();
     CellVisualizer.init('cell-towers');
     BMSChartManager.init();
-    const settings = new BMSSettings();
+
+    this.deltaPrefix = await this._fetchDeltaPrefix();
+    this.prefix = this.deltaPrefix + '.';
+
+    const settings = new BMSSettings(this.deltaPrefix);
     settings.init();
     this._connect();
   }
 
+  // The plugin's deltaPrefix setting decides which paths we read
+  async _fetchDeltaPrefix() {
+    try {
+      const res = await fetch(`${PLUGIN_API}/info`);
+      if (res.ok) {
+        const info = await res.json();
+        if (info.deltaPrefix) return info.deltaPrefix;
+      }
+    } catch (e) {
+      console.warn('[BMS] Could not read plugin info, using default path prefix', e);
+    }
+    return DEFAULT_PREFIX;
+  }
+
   // ---- Night mode ----
   _initNightMode() {
     const toggle = document.getElementById('nightModeToggle');
@@ -85,7 +107,7 @@ class BMSMonitor {
       this.ws.send(JSON.stringify({
         context: 'vessels.self',
         subscribe: [{
-          path: 'electrical.batteries.bms.*',
+          path: `${this.deltaPrefix}.*`,
           period: 1000
         }]
       }));

package/public/js/settings.js

@@ -1,9 +1,9 @@
 'use strict';
 
 class BMSSettings {
-  constructor() {
+  constructor(deltaPrefix = 'electrical.batteries.bms') {
     this.tempCommands = new Set(['TMAX', 'TMIN', 'TBAL', 'BMTH']);
-    this.prefix = 'electrical/batteries/bms';
+    this.prefix = deltaPrefix.replace(/\./g, '/');
 
     this.commandGroups = [
       { title: "Voltage Settings",      commands: ["BVOL","BMIN","CMAX","MAXH","CMIN","MINH","CHAR","CHIS","UBDI","CFVC","RAZL"] },
@@ -446,9 +446,19 @@ class BMSSettings {
         }
 
         btn.disabled = true;
-        const response = await this._sendCommand(`${cmd} ${value}`);
-        const ok = response && typeof response === 'object' && Object.keys(response).length > 0;
-        input.value = ok ? 'OK' : 'FAIL';
+        try {
+          const response = await this._sendCommand(`${cmd} ${value}`);
+          const ok = response && typeof response === 'object' && Object.keys(response).length > 0;
+          input.value = ok ? 'OK' : 'FAIL';
+        } catch (err) {
+          console.error(`[SETTINGS] ${cmd} failed:`, err);
+          input.value = 'FAIL';
+          input.classList.add('input-error');
+          const msg = document.createElement('div');
+          msg.className = 'input-error-msg';
+          msg.textContent = err.message;
+          input.parentElement.appendChild(msg);
+        }
         btn.disabled = false;
 
         setTimeout(() => this.prefillValues(), 5000);
@@ -509,12 +519,13 @@ class BMSSettings {
   }
 
   async _sendCommand(command) {
-    const res = await fetch('/signalk/v1/bms/command', {
+    const res = await fetch(`${PLUGIN_API}/command`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ command })
     });
-    const result = await res.json();
+    const result = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(result.error || `HTTP ${res.status}`);
     return result.response;
   }
 }