speedandcurrent 1.5.1 → 1.7.0

package/index.js

@@ -1,25 +1,106 @@
+const path = require('path');
+const fs = require('fs');
+
 const {
-  SmoothedHeading,
-  SmoothedAttitude,
-  SmoothedSpeedThroughWater,
-  SmoothedGroundSpeed,
+  SmoothedAngle,
   SI,
   MessageHandler,
   Polar,
   Reporter,
   BaseSmoother,
   MovingAverageSmoother,
+  ExponentialSmoother,
   KalmanSmoother,
   PolarSmoother,
   createSmoothedPolar,
-  createSmoothedHandler
+  createSmoothedHandler,
+  Table2D
 } = require('signalkutilities');
 
 const { CorrectionTable } = require('./correctionTable.js');
 
 module.exports = function (app) {
 
+  const DEFAULT_DIMS = { maxSpeed: 9, speedStep: 1, maxHeel: 32, heelStep: 8 };
+
+  let options = {};
+  let changedOptions = {};
+  const defaultOptions = {
+    sogFallback: true,
+    estimateBoatSpeed: false,
+    updateCorrectionTable: true,
+    stability: 7,
+    assumeCurrent: false,
+    headingSource: ' ',
+    boatSpeedSource: ' ',
+    COGSource: ' ',
+    SOGSource: ' ',
+    attitudeSource: ' ',
+    preventDuplication: true,
+    tableName: 'correctionTable',
+    smootherClass: 'MovingAverageSmoother',
+    smootherTau: 3,
+    smootherTimeSpan: 5,
+    smootherSteadyState: 0.2,
+    showStatistics: false
+  };
+
+  function readOptions() {
+    const stored = app.readPluginOptions();
+    const raw = stored && stored.configuration ? stored.configuration : (stored || {});
+    // Strip embedded table — stored separately on disk
+    const { correctionTable: _drop, ...rest } = raw;
+    options = { ...defaultOptions, ...rest };
+  }
+
+  function saveOptions() {
+    app.savePluginOptions({ ...options }, (err) => {
+      if (err) app.error(`Error saving plugin options: ${err.message}`);
+    });
+  }
+
+  function saveTableName(name) {
+    options.tableName = name;
+    saveOptions();
+  }
+
+  /**
+   * Derives { SmootherClass, smootherOptions } from the current options.
+   * Enforces minimums so the smoother always has at least two observations for
+   * variance to be meaningful:
+   *   - MovingAverageSmoother: timeSpan >= 2 s  (≥ 2 samples at typical 1 Hz)
+   *   - ExponentialSmoother:   tau        >= 1 s
+   *   - KalmanSmoother:        steadyState in [0.01, 0.99]
+   */
+  function resolveSmootherConfig() {
+    const cls = options.smootherClass || 'MovingAverageSmoother';
+    if (cls === 'ExponentialSmoother') {
+      return {
+        SmootherClass: ExponentialSmoother,
+        smootherOptions: { timeConstant: Math.max(1, Number(options.smootherTau) || 3) }
+      };
+    }
+    if (cls === 'KalmanSmoother') {
+      const K = Math.min(0.99, Math.max(0.01, Number(options.smootherSteadyState) || 0.2));
+      return {
+        SmootherClass: KalmanSmoother,
+        smootherOptions: { steadyState: K }
+      };
+    }
+    // Default: MovingAverageSmoother
+    return {
+      SmootherClass: MovingAverageSmoother,
+      smootherOptions: { timeSpan: Math.max(2, Number(options.smootherTimeSpan) || 5) }
+    };
+  }
+
+  function swapTable(newTable) {
+    table = newTable;
+    if (reportFull) reportFull.setTables([table]);
+  }
+
   let isRunning = false;
+  let pluginStatus = 'Stopped';
   let smoothedHeading = null;
   let stability = null;
   let smoothedAttitude = null;
@@ -50,192 +131,198 @@ module.exports = function (app) {
 
   plugin.schema = {
     type: "object",
-    properties: {
-      startWithNewTable: {
-        type: "boolean",
-        title: "Start with new table",
-        description: "Start with a new correction table (overrides existing table).",
-        default: false
-      },
-      estimateBoatSpeed: {
-        type: "boolean",
-        title: "Estimate Boat Speed",
-        description: "Enable estimation of boat speed.",
-        default: false
-      },
-      updateCorrectionTable: {
-        type: "boolean",
-        title: "Update Correction Table",
-        description: "Enable updating of the correction table.",
-        default: true
-      },
-      stability: {
-        type: "number",
-        title: "Correction Table Stability",
-        description: "Stability of the corrections (higher means that corrections are changed at a slower rate).",
-        default: 7,
-        minimum: 1,
-        maximum: 20
-      },
-      assumeCurrent: {
-        type: "boolean",
-        title: "Assume Current",
-        description: "Assume there is a current present when updating the correction table.",
-        default: false
-      },
-      heelStep: {
-        type: "number",
-        title: "Step size for heel",
-        description: "Correction table stepsize for heel.",
-        default: 8
-      },
-      maxHeel: {
-        type: "number",
-        title: "Maximum heel in correction table",
-        description: "Correction table maximum heel.",
-        default: 32
-      },
-      speedStep: {
-        type: "number",
-        title: "Step size for speed",
-        description: "Correction table stepsize for speed.",
-        default: 1
-      },
-      maxSpeed: {
-        type: "number",
-        title: "Maximum speed in correction table",
-        description: "Correction table maximum speed.",
-        default: 9
-      },
-      headingSource: {
-        type: "string",
-        title: "Heading Source",
-        description: "Source to use for navigation.heading (optional).",
-        default: " "
-      },
-      boatSpeedSource: {
-        type: "string",
-        title: "Boat Speed Source",
-        description: "Source to use for navigation.speedThroughWater (optional).",
-        default: " "
-      },
-      COGSource: {
-        type: "string",
-        title: "Course over ground",
-        description: "Source to use for navigation.courseOverGroundTrue (optional)",
-        default: " "
-      },
-      SOGSource: {
-        type: "string",
-        title: "Ground Speed Source",
-        description: "Source to use for navigation.speedOverGround (optional)",
-        default: " "
-      },
-      attitudeSource: {
-        type: "string",
-        title: "Attitude Source",
-        description: "Source to use for navigation.attitude (optional)",
-        default: " "
-      },
-      preventDuplication: {
-        type: "boolean",
-        title: "Prevent duplication of boat speed",
-        description: "Overwrite boat speed from sensor with corrected boat speed.",
-        default: true
-      }
-    }
+    description: "Speed and Current is configured through its own webapp. Open it from the Signal K app list.",
+    properties: {}
   };
 
-  plugin.uiSchema = {
-    'ui:order': [
-      "estimateBoatSpeed",
-      "updateCorrectionTable",
-      "assumeCurrent",
-      "startWithNewTable",
-      "stability",
-      "maxSpeed",
-      "speedStep",
-      "maxHeel",
-      "heelStep",
-      "headingSource",
-      "boatSpeedSource",
-      "COGSource",
-      "SOGSource",
-      "attitudeSource",
-      "preventDuplication"
-    ],
-    startWithNewTable: {
-      "ui:widget": "checkbox"
-    },
-    estimateBoatSpeed: {
-      "ui:widget": "checkbox"
-    },
-    updateCorrectionTable: {
-      "ui:widget": "checkbox"
-    },
-    stability: {
-      "ui:widget": "updown"
-    },
-    assumeCurrent: {
-      "ui:widget": "checkbox"
-    },
-    heelStep: {
-      "ui:widget": "updown"
-    },
-    maxHeel: {
-      "ui:widget": "updown"
-    },
-    speedStep: {
-      "ui:widget": "updown"
-    },
-    maxSpeed: {
-      "ui:widget": "updown"
-    },
-    mode: {
-      "ui:widget": "select"
-    },
-    preventDuplication: {
-      "ui:widget": "checkbox"
-    }
-  };
 
   plugin.registerWithRouter = function (router) {
     app.debug('registerWithRouter');
+    readOptions(); // pre-load so /api/settings works before start()
 
-    router.get('/getResults', (req, res) => {
+    router.get('/api/report', (req, res) => {
       if (!isRunning) {
         res.status(503).json({ error: "Plugin is not running" });
-      }
-      else {
+      } else {
         res.json(reportFull.report());
       }
     });
 
-    router.get('/getVectors', (req, res) => {
+    router.get('/api/meta', (req, res) => {
       if (!isRunning) {
         res.status(503).json({ error: "Plugin is not running" });
+      } else {
+        res.json(reportFull.meta());
       }
-      else {
+    });
+
+    router.get('/getVectors', (req, res) => {
+      if (!isRunning) {
+        res.status(503).json({ error: "Plugin is not running" });
+      } else {
         res.json(reportVector.report());
       }
     });
 
+    router.get('/api/status', (req, res) => {
+      res.json({ status: pluginStatus, isRunning });
+    });
+
+    // --- Settings API ---
+    router.get('/api/settings', (req, res) => {
+      res.json({ ...options, ...changedOptions });
+    });
+
+    router.put('/api/settings', (req, res) => {
+      const body = req.body;
+      if (!body || typeof body !== 'object') {
+        return res.status(400).json({ error: 'JSON body required' });
+      }
+      // Reject keys managed by the table manager
+      const blocked = ['correctionTable', 'tableName'];
+      for (const k of blocked) {
+        if (k in body) {
+          return res.status(400).json({ error: `Key '${k}' is managed via the table manager` });
+        }
+      }
+      changedOptions = { ...changedOptions, ...body };
+      res.json({ ...options, ...changedOptions });
+    });
+
+    // --- Correction Table Manager API ---
+
+    // List all table files in dataDir
+    router.get('/api/tables', (req, res) => {
+      const dataDir = app.getDataDirPath();
+      let files;
+      try { files = fs.readdirSync(dataDir).filter(f => f.endsWith('.json')); }
+      catch (e) { return res.json([]); }
+      const activeName = options.tableName || 'correctionTable';
+      const tables = [];
+      for (const file of files) {
+        try {
+          const data = Table2D.readFromFile(path.join(dataDir, file));
+          if (data && data.row && data.col && Array.isArray(data.table)) {
+            const name = file.replace(/\.json$/, '');
+            tables.push({ name, active: name === activeName });
+          }
+        } catch (e) { /* skip non-table files */ }
+      }
+      res.json(tables);
+    });
+
+    // Create a new table and hot-swap it
+    router.post('/api/tables/create', (req, res) => {
+      const body = req.body || {};
+      const name = (body.name || '').trim();
+      if (!name || !/^[\w-]+$/.test(name))
+        return res.status(400).json({ error: 'Name must be alphanumeric (underscores and hyphens allowed)' });
+      const dims = ['maxSpeed', 'speedStep', 'maxHeel', 'heelStep'];
+      for (const f of dims) {
+        if (!Number.isFinite(body[f]) || body[f] <= 0)
+          return res.status(400).json({ error: `Invalid or missing field: ${f}` });
+      }
+      const row = { min: 0, max: body.maxSpeed, step: body.speedStep };
+      const col = { min: -body.maxHeel, max: body.maxHeel, step: body.heelStep };
+      const newTable = new CorrectionTable(name, row, col, options.stability || 7);
+      newTable.setDisplayAttributes({ label: name }); // Table2D API unchanged
+      saveTable(newTable, path.join(app.getDataDirPath(), name + '.json'));
+      if (isRunning) swapTable(newTable);
+      saveTableName(name);
+      res.json({ name });
+    });
+
+    // Load a saved table and make it active
+    router.post('/api/tables/load', (req, res) => {
+      const body = req.body || {};
+      const name = (body.name || '').trim();
+      if (!name || !/^[\w-]+$/.test(name))
+        return res.status(400).json({ error: 'Invalid table name' });
+      const filePath = path.join(app.getDataDirPath(), name + '.json');
+      const fileData = Table2D.readFromFile(filePath);
+      if (!fileData) return res.status(404).json({ error: `Table '${name}' not found` });
+      const loadedTable = CorrectionTable.fromJSON(fileData, options.stability || 7);
+      loadedTable.setDisplayAttributes({ label: name }); // Table2D API unchanged
+      if (isRunning) swapTable(loadedTable);
+      saveTableName(name);
+      res.json({ name });
+    });
+
+    // Copy active table under a new name and hot-swap to it
+    router.post('/api/tables/copy', (req, res) => {
+      if (!isRunning || !table) return res.status(503).json({ error: 'Plugin is not running' });
+      const body = req.body || {};
+      const newName = (body.newName || '').trim();
+      if (!newName || !/^[\w-]+$/.test(newName))
+        return res.status(400).json({ error: 'Name must be alphanumeric (underscores and hyphens allowed)' });
+      const data = table.toJSON();
+      data.id = newName;
+      const copiedTable = CorrectionTable.fromJSON(data, options.stability || 7);
+      copiedTable.setDisplayAttributes({ label: newName }); // Table2D API unchanged
+      saveTable(copiedTable, path.join(app.getDataDirPath(), newName + '.json'));
+      swapTable(copiedTable);
+      saveTableName(newName);
+      res.json({ name: newName });
+    });
+
+    // Resize the active table (resamples onto new grid, preserves name)
+    router.post('/api/tables/resize', (req, res) => {
+      if (!isRunning || !table) return res.status(503).json({ error: 'Plugin is not running' });
+      const body = req.body || {};
+      const dims = ['maxSpeed', 'speedStep', 'maxHeel', 'heelStep'];
+      for (const f of dims) {
+        if (!Number.isFinite(body[f]) || body[f] <= 0)
+          return res.status(400).json({ error: `Invalid or missing field: ${f}` });
+      }
+      const newRow = { min: 0, max: body.maxSpeed, step: body.speedStep };
+      const newCol = { min: -body.maxHeel, max: body.maxHeel, step: body.heelStep };
+      const resized = CorrectionTable.resampleFromJSON(table.toJSON(), newRow, newCol, options.stability || 7, 1e-4);
+      resized.setDisplayAttributes({ label: resized.id }); // Table2D API unchanged
+      saveTable(resized, path.join(app.getDataDirPath(), resized.id + '.json'));
+      swapTable(resized);
+      res.json({ name: resized.id });
+    });
+
+  }
+
+  function setStatus(msg) {
+    pluginStatus = msg;
+    app.setPluginStatus(msg);
   }
 
   plugin.start = (settings) => {
-    app.setPluginStatus("Starting");
+    setStatus('Starting');
     app.debug("Starting");
-    table = loadTable(settings);
+    readOptions(); // pick up any saves since registerWithRouter ran
+    const tableName = options.tableName || 'correctionTable';
+    const tableFilePath = path.join(app.getDataDirPath(), tableName + '.json');
+    table = loadTable(options, tableFilePath);
 
     //#region Handler and Polar Initialization
-    let smootherOptions = { timeConstant: 1, processVariance: 1, measurementVariance: 20, timeSpan: 5 };
+    const { SmootherClass, smootherOptions } = resolveSmootherConfig();
 
     // heading
-    smoothedHeading = new SmoothedHeading(app, plugin.id, settings.headingSource, true, MovingAverageSmoother, smootherOptions);
-    rawHeading = smoothedHeading.polar.angleHandler;
+    smoothedHeading = new SmoothedAngle(app, plugin.id, 'heading', 'navigation.headingTrue', {
+      source: options.headingSource,
+      passOn: true,
+      angleRange: '0to2pi',
+      meta: { displayName: 'Heading', plane: 'Ground' },
+      SmootherClass,
+      smootherOptions
+    });
+    rawHeading = smoothedHeading.handler;
 
     //attitude
-    smoothedAttitude = new SmoothedAttitude(app, plugin.id, settings.attitudeSource, true, MovingAverageSmoother, smootherOptions);
+    smoothedAttitude = createSmoothedHandler({
+      app, pluginId: plugin.id,
+      id: 'attitude',
+      path: 'navigation.attitude',
+      source: options.attitudeSource,
+      passOn: true,
+      subscribe: true,
+      SmootherClass,
+      smootherOptions
+    });
     rawAttitude = smoothedAttitude.handler;
 
 
@@ -243,12 +330,13 @@ module.exports = function (app) {
     // send metadata for current
     MessageHandler.setMeta(app, plugin.id, "environment.current.drift", {units: "m/s", type: "number", description: "Speed of the current"});
     MessageHandler.setMeta(app, plugin.id, "environment.current.setTrue", { units: "rad", type: "number", description: "Direction of the current" });
-    rawCurrent = new Polar("current", "self.environment.current.drift", "self.environment.current.setTrue");
-    rawCurrent.setDisplayAttributes({ label: "current", plane: "Ground" });
+    rawCurrent = new Polar(app, plugin.id, "current");
+    rawCurrent.configureMagnitude("self.environment.current.drift");
+    rawCurrent.configureAngle("self.environment.current.setTrue");
+    rawCurrent.setMeta({ displayName: "Current", plane: "Ground" });
     rawCurrent.setAngleRange('0to2pi');
-    smoothedCurrent = new PolarSmoother("currentDamped", rawCurrent, KalmanSmoother, { processVariance: 0.000001, measurementVariance: 0.01 });
+    smoothedCurrent = new PolarSmoother(rawCurrent, KalmanSmoother, { processVariance: 0.000001, measurementVariance: 0.01 }); // id auto-derived: 'current.smoothed'
     smoothedCurrent.setAngleRange('0to2pi');
-    smoothedCurrent.setDisplayAttributes({ label: "Current", plane: "Ground" });
     // Current should be initialised as no current
     rawCurrent.setVectorValue({ x: 0, y: 0 });
     // Strongly assume no current at start
@@ -256,7 +344,7 @@ module.exports = function (app) {
     smoothedCurrent.ySmoother.reset(0, 0.00000001);
     // no current
     noCurrent = createSmoothedPolar({
-      id: "boatSpeed",
+      id: "noCurrent",
       pathMagnitude: "self.environment.current.drift",
       pathAngle: "self.environment.current.setTrue",
       subscribe: false,
@@ -264,71 +352,86 @@ module.exports = function (app) {
       pluginId: plugin.id,
       SmootherClass: BaseSmoother,
       smootherOptions: smootherOptions,
-      displayAttributes: { label: "NoCurrent", plane: "Ground" },
+      meta: { displayName: "NoCurrent", plane: "Ground" },
     });
     noCurrent.xSmoother.reset(0,0);
     noCurrent.ySmoother.reset(0,0);
     PolarSmoother.send(app, plugin.id, [noCurrent]);
 
 
-    // boat speed
-    smoothedBoatSpeed = new SmoothedSpeedThroughWater(app, plugin.id, settings.boatSpeedSource, true, MovingAverageSmoother, smootherOptions, !settings.preventDuplication);
-    rawBoatSpeed = smoothedBoatSpeed.polar;
-    correctedBoatSpeed = new Polar("correctedBoatSpeed", "navigation.speedThroughWater", "navigation.leewayAngle");
-    correctedBoatSpeed.setDisplayAttributes({ label: "corrected boat speed", plane: "Boat" });
-    boatSpeedRefGround = new Polar("boatSpeedRefGround");
-    boatSpeedRefGround.setDisplayAttributes("Boat speed over ground", "Ground");
- 
+    // boat speed — STW magnitude is optionally forwarded; leeway angle passOn is always false
+    const rawBoatSpeedPolar = new Polar(app, plugin.id, 'boatSpeed');
+    rawBoatSpeedPolar.configureMagnitude('navigation.speedThroughWater', options.boatSpeedSource, !options.preventDuplication);
+    rawBoatSpeedPolar.configureAngle('navigation.leewayAngle', options.boatSpeedSource, false);
+    rawBoatSpeedPolar.setMeta({ displayName: 'Boat speed', plane: 'Boat' });
+    rawBoatSpeedPolar.setAngleRange('-piToPi');
+    rawBoatSpeedPolar.subscribe(true, false);
+    smoothedBoatSpeed = new PolarSmoother(rawBoatSpeedPolar, SmootherClass, smootherOptions);
+    rawBoatSpeedPolar.onChange = () => { smoothedBoatSpeed.sample(); };
+    rawBoatSpeed = rawBoatSpeedPolar;
+    correctedBoatSpeed = new Polar(app, plugin.id, "correctedBoatSpeed");
+    correctedBoatSpeed.configureMagnitude("navigation.speedThroughWater");
+    correctedBoatSpeed.configureAngle("navigation.leewayAngle");
+    correctedBoatSpeed.setMeta({ displayName: "Corrected boatspeed / Leeway", plane: "Boat" });
+    boatSpeedRefGround = new Polar(app, plugin.id, "boatSpeedRefGround");
+    boatSpeedRefGround.setMeta({ displayName: "Boat speed over ground", plane: "Ground" });
+
     // ground speed
-    smoothedGroundSpeed = new SmoothedGroundSpeed(app, plugin.id, settings.SOGSource, true, MovingAverageSmoother, smootherOptions, !settings.preventDuplication);
+    smoothedGroundSpeed = createSmoothedPolar({
+      app, pluginId: plugin.id,
+      id: 'groundSpeed',
+      pathMagnitude: 'navigation.speedOverGround',
+      pathAngle: 'navigation.courseOverGroundTrue',
+      source: options.SOGSource,
+      passOn: true,
+      angleRange: '0to2pi',
+      meta: { displayName: 'Groundspeed', plane: 'Ground' },
+      SmootherClass,
+      smootherOptions
+    });
     rawGroundSpeed = smoothedGroundSpeed.polar;
 
     // correction vector
-    speedCorrection = new Polar("speedCorrection");
-    speedCorrection.setDisplayAttributes("speed correction", "Boat");
-    speedCorrection.setDisplayAttributes({ label: "speed correction", plane: "Boat" });
+    speedCorrection = new Polar(app, plugin.id, "speedCorrection");
+    speedCorrection.setMeta({ displayName: "Speed correction", plane: "Boat" });
 
     // residual
-    residual = new Polar("residual");
-    residual.setDisplayAttributes({ label: "residual", plane: "Ground" });
+    residual = new Polar(app, plugin.id, "residual");
+    residual.setMeta({ displayName: "Residual", plane: "Ground" });
 
     //#endregion
 
     //#region Reporting
     reportFull = new Reporter();
 
-    if (settings.estimateBoatSpeed) {
+    if (options.estimateBoatSpeed) {
       reportFull.addDelta(rawHeading);
       reportFull.addAttitude(rawAttitude);
       reportFull.addPolar(rawBoatSpeed);
       reportFull.addPolar(speedCorrection);
+      reportFull.addPolar(boatSpeedRefGround);
       reportFull.addPolar(correctedBoatSpeed);
       reportFull.addPolar(rawGroundSpeed);
       reportFull.addPolar(smoothedCurrent);
     }
-    if (settings.updateCorrectionTable) {
+    if (options.updateCorrectionTable) {
       reportFull.addDelta(smoothedHeading);
       reportFull.addAttitude(smoothedAttitude);
       reportFull.addPolar(smoothedBoatSpeed);
       reportFull.addPolar(smoothedGroundSpeed);
-
-        if (settings.assumeCurrent) {
-          reportFull.addPolar(boatSpeedRefGround);
-          reportFull.addPolar(smoothedCurrent);
-        }
-      reportFull.addPolar(speedCorrection);
+      if (options.assumeCurrent) {
+        reportFull.addPolar(smoothedCurrent);
+      }
       reportFull.addPolar(residual);
     }
     reportFull.addTable(table);
 
     // Make reporting object for webApp
-
-
     reportVector = new Reporter();
     reportVector.addDelta(rawHeading);
     reportVector.addPolar(residual);
     reportVector.addPolar(speedCorrection);
-    if (settings.assumeCurrent) reportVector.addPolar(smoothedCurrent);
+    if (options.assumeCurrent) reportVector.addPolar(smoothedCurrent);
     reportVector.addPolar(correctedBoatSpeed);
     reportVector.addPolar(rawBoatSpeed);
     reportVector.addPolar(rawGroundSpeed);
@@ -336,20 +439,34 @@ module.exports = function (app) {
 
     isRunning = true;
     started = new Date();
-    app.setPluginStatus("Running");
+    setStatus('Running');
     app.debug("Running");
 
     let lastSave = 0;
     smoothedBoatSpeed.onChange = () => {
+      // Drain any pending option changes before calculating
+      if (Object.keys(changedOptions).length) applyOptionChanges();
+
       const wellUnderway = started < new Date() - 60 * 1000;
-      const minSpeed = SI.fromKnots(settings.speedStep / 2);
-      if (settings.estimateBoatSpeed) correct(wellUnderway);
-      if (settings.updateCorrectionTable && wellUnderway) {
-        updateTable(settings.assumeCurrent, minSpeed);
-        // Save correction table periodically 
+      const minSpeed = SI.fromKnots(options.speedStep / 2);
+
+      if (options.sogFallback && fallingBackToSog(minSpeed)) {
+        setStatus('Falling back to Speed Over Ground');
+        app.debug("Falling back");
+        return;
+      }
+      if (!wellUnderway) {
+        setStatus('Stabilizing');
+      } else {
+        setStatus('Running');
+      }
+      if (options.estimateBoatSpeed) correct(wellUnderway);
+      if (options.updateCorrectionTable && wellUnderway) {
+        updateTable(options.assumeCurrent, minSpeed);
+        // Save correction table periodically
         const now = new Date();
         if (now - lastSave > 5 * 1000) {
-          saveTable(settings, table);
+          saveTable(table, path.join(app.getDataDirPath(), table.id + '.json'));
           lastSave = now;
         }
       }
@@ -359,17 +476,17 @@ module.exports = function (app) {
   plugin.stop = () => {
     return new Promise((resolve, reject) => {
       try {
-        smoothedHeading = smoothedHeading?.terminate(app);
-        stability = stability?.terminate?.(app);
-        smoothedAttitude = smoothedAttitude?.terminate(app);
-        rawCurrent = rawCurrent?.terminate(app);
-        smoothedCurrent = smoothedCurrent?.terminate?.(app);
-        smoothedBoatSpeed = smoothedBoatSpeed?.terminate(app);
-        correctedBoatSpeed = correctedBoatSpeed?.terminate(app);
-        boatSpeedRefGround = boatSpeedRefGround?.terminate(app);
-        smoothedGroundSpeed = smoothedGroundSpeed?.terminate(app);
-        speedCorrection = speedCorrection?.terminate(app);
-        residual = residual?.terminate(app);
+        smoothedHeading = smoothedHeading?.terminate();
+        stability = stability?.terminate?.();
+        smoothedAttitude = smoothedAttitude?.terminate();
+        rawCurrent = rawCurrent?.terminate();
+        smoothedCurrent = smoothedCurrent?.terminate?.();
+        smoothedBoatSpeed = smoothedBoatSpeed?.terminate();
+        correctedBoatSpeed = correctedBoatSpeed?.terminate();
+        boatSpeedRefGround = boatSpeedRefGround?.terminate();
+        smoothedGroundSpeed = smoothedGroundSpeed?.terminate();
+        speedCorrection = speedCorrection?.terminate();
+        residual = residual?.terminate();
         reportFull = null;
         reportVector = null;
         table = null;
@@ -382,6 +499,7 @@ module.exports = function (app) {
         app.setPluginStatus("Stopped");
         app.debug("Stopped");
 
+        pluginStatus = 'Stopped';
         isRunning = false;
         resolve();
       } catch (error) {
@@ -390,6 +508,15 @@ module.exports = function (app) {
     });
   };
 
+  function fallingBackToSog( minSpeed) {
+    if (!rawBoatSpeed.stale && rawBoatSpeed.magnitude > 0) return false;
+    if (rawGroundSpeed.stale || rawGroundSpeed.magnitude < minSpeed) return false;
+    // Fallback to SOG
+    correctedBoatSpeed.setVectorValue({ x: rawGroundSpeed.magnitude, y: 0 });
+    Polar.send(app, plugin.id, [correctedBoatSpeed]);
+    return true;
+  }
+
    /**
    * Estimates and applies corrections to boat speed, leeway, and current.
    *
@@ -474,17 +601,15 @@ module.exports = function (app) {
    * @param {Object} col - The expected column configuration ({ min, max, step }).
    * @returns {boolean} True if the table matches the configuration, false otherwise.
    */
-  function enforceConsistancy(options, row, col) {
-    if (!options?.correctionTable) return false;
-    table = options.correctionTable;
-    if (!table) return false;
-    if (!table.row) return false;
-    if (table.row.min != row.min) return false;
-    if (table.row.max != row.max) return false;
-    if (table.row.step != row.step) return false;
-    if (table.col.min != col.min) return false;
-    if (table.col.max != col.max) return false;
-    if (table.col.step != col.step) return false;
+  function enforceConsistancy(data, row, col) {
+    if (!data) return false;
+    if (!data.row) return false;
+    if (data.row.min != row.min) return false;
+    if (data.row.max != row.max) return false;
+    if (data.row.step != row.step) return false;
+    if (data.col.min != col.min) return false;
+    if (data.col.max != col.max) return false;
+    if (data.col.step != col.step) return false;
     return true;
   }
 
@@ -498,30 +623,21 @@ module.exports = function (app) {
    * @param {Object} options - The plugin options containing correction table settings and parameters.
    * @returns {CorrectionTable} The loaded or newly created CorrectionTable instance.
    */
-  function loadTable(options) {
-    const row = { min: 0, max: SI.fromKnots(options.maxSpeed), step: SI.fromKnots(options.speedStep) };
-    const col = { min: -SI.fromDegrees(options.maxHeel), max: SI.fromDegrees(options.maxHeel), step: SI.fromDegrees(options.heelStep) };
-    let table;
+  function loadTable(options, filePath) {
     const stability = (options.stability !== undefined) ? options.stability : 6;
-    const VAR_FLOOR = 1e-4;
-    if (enforceConsistancy(options, row, col) && !options.startWithNewTable) {
-      table = CorrectionTable.fromJSON(options.correctionTable, stability);
-      app.debug("Correction table loaded");
-    }
-    else if (options.correctionTable && !options.startWithNewTable) {
-      // Resample existing table to new dimensions conservatively (N=0, diag covariance with floor)
-      table = CorrectionTable.resampleFromJSON(options.correctionTable, row, col, stability, VAR_FLOOR);
-      app.debug("Correction table migrated to new dimensions");
-      options.startWithNewTable = false;
-      saveTable(options, table);
+    const fileData = Table2D.readFromFile(filePath);
+    let table;
+    if (fileData) {
+      table = CorrectionTable.fromJSON(fileData, stability);
+      app.debug("Correction table loaded: " + (fileData.id || filePath));
     } else {
-      table = new CorrectionTable("correctionTable", row, col, stability);
-      app.debug("Correction table created");
-      // doStartFresh is not user-settable, so no need to reset it here
-      options.startWithNewTable = false;
-      saveTable(options, table);
+      const name = options.tableName || 'correctionTable';
+      const row = { min: 0, max: SI.fromKnots(DEFAULT_DIMS.maxSpeed), step: SI.fromKnots(DEFAULT_DIMS.speedStep) };
+      const col = { min: -SI.fromDegrees(DEFAULT_DIMS.maxHeel), max: SI.fromDegrees(DEFAULT_DIMS.maxHeel), step: SI.fromDegrees(DEFAULT_DIMS.heelStep) };
+      table = new CorrectionTable(name, row, col, stability);
+      app.debug("Correction table created: " + name);
     }
-    table.setDisplayAttributes({ label: "correction table" });
+    table.setDisplayAttributes({ label: table.id }); // Table2D API unchanged
     return table;
   }
 
@@ -536,9 +652,52 @@ module.exports = function (app) {
    * @param {CorrectionTable} correctionTable - The correction table instance to save.
    * @returns {Date} The date and time when the table was saved.
    */
-  function saveTable(options, correctionTable) {
-  options.correctionTable = correctionTable.toJSON();
-  app.savePluginOptions(options, () => { /*app.debug("Correction table saved")*/; });
+  function saveTable(correctionTable, filePath) {
+    correctionTable.saveToFile(filePath);
+  }
+
+  /**
+   * Drains changedOptions into options and hot-applies each change where possible.
+   * Source changes are applied in-place on existing handlers; flag changes take
+   * effect immediately since onChange reads from options.* directly.
+   */
+  function applyOptionChanges() {
+    const changedKeys = Object.keys(changedOptions);
+    for (const key of changedKeys) {
+      const value = changedOptions[key];
+      options[key] = value;
+
+      // Hot-apply source changes by mutating handler references in-place
+      if (smoothedHeading && key === 'headingSource') {
+        smoothedHeading.handler.source = value;
+      } else if (smoothedAttitude && key === 'attitudeSource') {
+        smoothedAttitude.handler.source = value;
+      } else if (smoothedBoatSpeed && key === 'boatSpeedSource') {
+        smoothedBoatSpeed.polar.magnitudeHandler.source = value;
+      } else if (smoothedGroundSpeed && key === 'SOGSource') {
+        smoothedGroundSpeed.polar.magnitudeHandler.source = value;
+      } else if (key === 'preventDuplication') {
+        if (smoothedBoatSpeed) smoothedBoatSpeed.polar.magnitudeHandler.passOn = !value;
+      }
+      // All other keys (sogFallback, estimateBoatSpeed, updateCorrectionTable,
+      // assumeCurrent, stability, startWithNewTable, COGSource) are read
+      // directly from options.* so no extra action needed.
+
+      delete changedOptions[key];
+    }
+
+    // Hot-apply smoother class / parameter changes to all user-tuned smoothers.
+    // (noCurrent and smoothedCurrent keep their own fixed Kalman settings.)
+    const SMOOTHER_KEYS = ['smootherClass', 'smootherTau', 'smootherTimeSpan', 'smootherSteadyState'];
+    if (changedKeys.some(k => SMOOTHER_KEYS.includes(k))) {
+      const { SmootherClass: SC, smootherOptions: so } = resolveSmootherConfig();
+      for (const s of [smoothedHeading, smoothedBoatSpeed, smoothedGroundSpeed]) {
+        if (s) { s.setSmootherClass(SC); s.setSmootherOptions(so); }
+      }
+      if (smoothedAttitude) { smoothedAttitude.setSmootherClass(SC); smoothedAttitude.setSmootherOptions(so); }
+    }
+
+    saveOptions();
   }
 
   return plugin;