signalk-sailboat-simulator 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.2.0] - 2026-08-17
+
+- Follow `steering.autopilot.output.turnRate` from `signalk-autopilot-emulator-v2` directly instead of deriving and rate-limiting turns from autopilot target headings.
+- Remove simulator-side heading target and wind steering logic; the autopilot emulator is now responsible for producing the turn-rate output.
+- Keep simulator steering based on true heading and publish `navigation.headingMagnetic` only when `navigation.magneticVariation` is available.
+
 ## [0.1.0] - 2026-08-14
 
 - Initial public release.

package/README.md

@@ -1,6 +1,6 @@
 # Signal K Sailboat Simulator
 
-Signal K plugin that simulates a sailing boat by integrating a virtual position from data already present in Signal K: target heading, weather and polar performance.
+Signal K plugin that simulates a sailing boat by integrating a virtual position from data already present in Signal K: autopilot turn-rate output, weather and polar performance.
 
 The design goal is to keep this plugin small. It publishes only the simulated vessel state and expects specialised plugins to provide autopilot intent, weather and polar calculations.
 
@@ -10,13 +10,13 @@ The easiest setup is to use the Signal K App Store:
 
 1. Install these recommended plugins:
    - `@signalk/open-meteo-provider`
-   - `@signalk/signalk-autopilot`
+   - `signalk-autopilot-emulator-v2`
    - `signalk-polar-performance-plugin`
    - `signalk-derived-data`
    - `signalk-distance-to-shore`
 2. Configure `@signalk/open-meteo-provider` and make it the default Signal K Weather API provider. You can also leave the Signal K default as-is and set `wind.providerId` to `open-meteo` in this plugin.
 3. Configure `signalk-polar-performance-plugin` with a polar file for the simulated boat.
-4. Configure `signalk-derived-data` to publish `navigation.magneticVariation`. This is needed by the autopilot plugin when magnetic headings are involved, and lets the simulator publish `navigation.headingMagnetic`.
+4. Configure `signalk-derived-data` to publish `navigation.magneticVariation`, so the simulator can publish `navigation.headingMagnetic` for plugins that need magnetic heading.
 5. Install and enable `signalk-sailboat-simulator`.
 6. Keep the default simulator options for a first run.
 7. Open the Signal K Data Browser or Freeboard and check that the simulated vessel position, wind and boat speed are updating.
@@ -34,10 +34,10 @@ Then restart Signal K and enable the plugin from the Server > Plugin Config page
 
 Minimum capabilities for a useful simulation:
 
-- Autopilot intent: `@signalk/signalk-autopilot` can provide heading and wind-mode targets under `steering.autopilot.*`.
+- Autopilot output: `signalk-autopilot-emulator-v2` provides `steering.autopilot.output.turnRate`, which the simulator integrates as the boat heading change.
 - Weather: `@signalk/open-meteo-provider` can provide Weather API observations or forecasts at the simulated position.
 - Polar performance: `signalk-polar-performance-plugin` uses the published true wind values to calculate `performance.polarSpeed`, which the simulator uses as boat speed.
-- Derived data: enable the `signalk-derived-data` option that publishes `navigation.magneticVariation`. The autopilot plugin needs it for magnetic heading handling, and the simulator uses it to derive or publish magnetic headings.
+- Derived data: enable the `signalk-derived-data` option that publishes `navigation.magneticVariation`; when this path is available, the simulator also publishes `navigation.headingMagnetic` for plugins that need magnetic heading.
 - Shore distance: `signalk-distance-to-shore` can provide `navigation.distanceToShore` and `navigation.shore.bearingTrue` for grounding protection.
 
 ## Verify It Works
@@ -67,17 +67,14 @@ Performance input expected by the simulator:
 
 All values are published with `$source: signalk-sailboat-simulator`.
 
-The plugin status will show `waitingForPerformance` until `performance.polarSpeed` is available. If grounding protection is enabled and `navigation.distanceToShore` is below the configured minimum, the status will show `groundingProtection` and the simulated boat will stop.
+The plugin status will show `waitingForPerformance` until `performance.polarSpeed` is available. If `steering.autopilot.output.turnRate` is missing, the simulated boat keeps its current heading. If grounding protection is enabled and `navigation.distanceToShore` is below the configured minimum, the status will show `groundingProtection` and the simulated boat will stop.
 
 ## Input contract
 
 The simulator reads these fixed Signal K input paths:
 
-- `steering.autopilot.target.headingTrue`: desired true heading in radians
-- `steering.autopilot.target.headingMagnetic`: desired magnetic heading in radians
-- `steering.autopilot.mode`: autopilot mode; when it is `wind`, wind steering is enabled
-- `steering.autopilot.target.windAngleApparent`: desired apparent wind angle in radians
-- `navigation.magneticVariation`: magnetic variation in radians, added to magnetic heading to derive true heading
+- `steering.autopilot.output.turnRate`: desired heading change rate in rad/s
+- `navigation.magneticVariation`: optional magnetic variation in radians, used only to publish `navigation.headingMagnetic`
 - `performance.polarSpeed`: boat speed from the active polar in m/s
 - `navigation.distanceToShore`: optional distance to the nearest coast in m, used for grounding protection
 - `navigation.shore.bearingTrue`: optional bearing from the vessel to the nearest coast in radians, used to allow recovery headings away from shore
@@ -88,16 +85,6 @@ By default the simulator uses the Signal K default weather provider. Set `wind.p
 
 When no usable weather data is available yet, for example while the weather provider is still starting up, the simulator retries faster instead of waiting for the normal polling interval.
 
-If `steering.autopilot.target.headingTrue` is missing, the simulator derives the true heading from the autopilot magnetic target:
-
-```text
-headingTrue = steering.autopilot.target.headingMagnetic + navigation.magneticVariation
-```
-
-For the current Signal K autopilot emulator, `steering.autopilot.target` is also read as a fallback because the target value may be exposed there.
-
-When the autopilot mode is `wind`, the simulator ignores stale heading targets and derives the boat heading from `steering.autopilot.target.windAngleApparent`, true wind speed/direction, and boat speed. This lets the virtual boat hold the requested apparent wind angle.
-
 The simulator publishes virtual wind for the rest of the Signal K stack. The publish options are grouped as true wind and apparent wind:
 
 - `environment.wind.speedTrue`
@@ -108,7 +95,7 @@ The simulator publishes virtual wind for the rest of the Signal K stack. The pub
 
 This gives `signalk-polar-performance-plugin` the `environment.wind.speedTrue` and `environment.wind.angleTrueWater` inputs it needs to calculate `performance.polarSpeed`.
 
-The first version uses `performance.polarSpeed` as the boat speed and integrates the position along the target heading. Current, leeway, route following and manoeuvre rules are intentionally left as separate steps.
+The first version uses `performance.polarSpeed` as the boat speed, integrates heading from `steering.autopilot.output.turnRate`, and integrates position along that simulated heading. Current, leeway, route following and manoeuvre rules are intentionally left as separate steps.
 
 ## Configuration
 
@@ -129,9 +116,9 @@ The plugin intentionally keeps its configuration surface small:
 
 - `publishing`
   What it does: publishes the simulated navigation state.
-  Requires: `steering.autopilot.*` target data to steer and `performance.polarSpeed` to move. Recommended providers are `@signalk/signalk-autopilot` and `signalk-polar-performance-plugin`.
+  Requires: `steering.autopilot.output.turnRate` to steer and `performance.polarSpeed` to move. Recommended providers are `signalk-autopilot-emulator-v2`, `signalk-polar-performance-plugin`, and `signalk-derived-data` when magnetic heading output is needed.
   Options: publish navigation state.
-  Published paths: `navigation.position`, `navigation.headingTrue`, `navigation.headingMagnetic` when available, `navigation.courseOverGroundTrue`, `navigation.speedOverGround`, `navigation.speedThroughWater`.
+  Published paths: `navigation.position`, `navigation.headingTrue`, `navigation.headingMagnetic` when `navigation.magneticVariation` is available, `navigation.courseOverGroundTrue`, `navigation.speedOverGround`, `navigation.speedThroughWater`.
 
 - `grounding`
   What it does: stops the simulated boat when it gets too close to shore, while still allowing headings that move away from the nearest shore.
@@ -146,10 +133,6 @@ The plugin intentionally keeps its configuration surface small:
 
 Signal K input paths, simulation tick timing, turn rate and persistence save timing are fixed defaults rather than UI options.
 
-## Boat Dynamics
-
-The simulator does not instantly snap to the autopilot target heading. It turns the virtual boat toward the target at `dynamics.maxTurnRateDegPerSecond`, which defaults to 3 degrees per second.
-
 ## Grounding Protection
 
 When `grounding.enabled` is true, the simulator reads `navigation.distanceToShore` and stops the virtual boat when the value is less than or equal to `grounding.minimumDistanceToShore`, which defaults to 20 meters. If `navigation.shore.bearingTrue` is available, the simulator still allows movement when the selected heading points away from the nearest shore.
@@ -163,8 +146,7 @@ The simulator saves its latest runtime state every 10 seconds by default and res
 Persisted values include:
 
 - position
-- true and magnetic heading
-- magnetic variation
+- true heading
 - COG, SOG and STW
 
 ## Uninstall
@@ -184,9 +166,9 @@ Then restart Signal K.
 
 - Signal K Weather Providers: https://demo.signalk.org/documentation/Developing/Plugins/Weather_Providers.html
 - Signal K Weather API: https://demo.signalk.org/documentation/Developing/REST_APIs/Weather_API.html
-- Signal K Autopilot Providers: https://demo.signalk.org/documentation/develop/plugins/autopilot_provider_plugins.html
 - `@signalk/open-meteo-provider`: https://www.npmjs.com/package/@signalk/open-meteo-provider
-- `@signalk/signalk-autopilot`: https://www.npmjs.com/package/@signalk/signalk-autopilot
+- `signalk-autopilot-emulator-v2`: https://www.npmjs.com/package/signalk-autopilot-emulator-v2
+- `signalk-autopilot-emulator-v2` source: https://github.com/macjl/signalk-autopilot-emulator-v2
 - `signalk-polar-performance-plugin`: https://www.npmjs.com/package/signalk-polar-performance-plugin
 - `signalk-derived-data`: https://www.npmjs.com/package/signalk-derived-data
 - `signalk-distance-to-shore`: https://www.npmjs.com/package/signalk-distance-to-shore

package/index.js

@@ -2,7 +2,7 @@
 
 const { createInitialState, stepSimulation } = require('./lib/simulation-engine')
 const { buildSchema } = require('./lib/plugin-schema')
-const { degToRad, radToDeg } = require('./lib/angles')
+const { degToRad, radToDeg, wrap360Rad } = require('./lib/angles')
 const { apparentWindFromTrue, trueWindFromDirection, windSnapshotFromObservation } = require('./lib/wind')
 const { applyPersistedState, createStateStore, stateFromSimulation } = require('./lib/state-store')
 
@@ -10,11 +10,7 @@ const PLUGIN_ID = 'sailboat-simulator'
 const PUBLISH_SOURCE = 'signalk-sailboat-simulator'
 
 const INPUT_PATHS = {
-  autopilotModePath: 'steering.autopilot.mode',
-  targetHeadingTruePath: 'steering.autopilot.target.headingTrue',
-  targetHeadingMagneticPath: 'steering.autopilot.target.headingMagnetic',
-  targetHeadingMagneticFallbackPath: 'steering.autopilot.target',
-  targetWindAngleApparentPath: 'steering.autopilot.target.windAngleApparent',
+  turnRatePath: 'steering.autopilot.output.turnRate',
   magneticVariationPath: 'navigation.magneticVariation',
   performanceSpeedPath: 'performance.polarSpeed',
   distanceToShorePath: 'navigation.distanceToShore',
@@ -40,9 +36,6 @@ const DEFAULT_OPTIONS = {
   fallback: {
     speedThroughWater: 0
   },
-  dynamics: {
-    maxTurnRateDegPerSecond: 3
-  },
   grounding: {
     enabled: true,
     minimumDistanceToShore: 20
@@ -71,7 +64,7 @@ module.exports = function createPlugin (app) {
   const plugin = {
     id: PLUGIN_ID,
     name: 'Sailboat Simulator',
-    description: 'Simulates a sailing boat position from Signal K heading, weather and polar performance data.',
+    description: 'Simulates a sailing boat position from Signal K autopilot turn-rate output, weather and polar performance data.',
     schema: buildSchema,
     start,
     stop,
@@ -136,13 +129,7 @@ module.exports = function createPlugin (app) {
   function readInputs () {
     const weatherWind = freshWeatherWind()
     return {
-      autopilotMode: readString(INPUT_PATHS.autopilotModePath) || readString('steering.autopilot.state'),
-      targetHeadingTrue: readNumber(INPUT_PATHS.targetHeadingTruePath),
-      targetHeadingMagnetic: readFirstNumber([
-        INPUT_PATHS.targetHeadingMagneticPath,
-        INPUT_PATHS.targetHeadingMagneticFallbackPath
-      ]),
-      targetWindAngleApparent: readNumber(INPUT_PATHS.targetWindAngleApparentPath),
+      turnRate: readNumber(INPUT_PATHS.turnRatePath),
       magneticVariation: readNumber(INPUT_PATHS.magneticVariationPath),
       polarSpeed: readNumber(INPUT_PATHS.performanceSpeedPath),
       windSpeedTrue: weatherWind && weatherWind.speedTrue != null
@@ -164,20 +151,6 @@ module.exports = function createPlugin (app) {
     return Number.isFinite(value) ? value : null
   }
 
-  function readString (path) {
-    if (!path || typeof app.getSelfPath !== 'function') return null
-    const value = app.getSelfPath(`${path}.value`)
-    return typeof value === 'string' ? value : null
-  }
-
-  function readFirstNumber (paths) {
-    for (const path of paths) {
-      const value = readNumber(path)
-      if (Number.isFinite(value)) return value
-    }
-    return null
-  }
-
   function publishState (inputs) {
     if (!state || !app.handleMessage) return
 
@@ -191,12 +164,13 @@ module.exports = function createPlugin (app) {
         }
       })
       values.push({ path: 'navigation.headingTrue', value: state.headingTrue })
+      const headingMagnetic = magneticHeadingFromTrue(state.headingTrue, inputs.magneticVariation)
+      if (Number.isFinite(headingMagnetic)) {
+        values.push({ path: 'navigation.headingMagnetic', value: headingMagnetic })
+      }
       values.push({ path: 'navigation.courseOverGroundTrue', value: state.courseOverGroundTrue })
       values.push({ path: 'navigation.speedOverGround', value: state.speedOverGround })
       values.push({ path: 'navigation.speedThroughWater', value: state.speedThroughWater })
-      if (Number.isFinite(state.headingMagnetic)) {
-        values.push({ path: 'navigation.headingMagnetic', value: state.headingMagnetic })
-      }
     }
     values.push(...buildWindValues(inputs))
 
@@ -379,14 +353,15 @@ module.exports = function createPlugin (app) {
   }
 
   function updateRuntime (inputs) {
+    const headingMagnetic = magneticHeadingFromTrue(state.headingTrue, inputs.magneticVariation)
     runtime = {
       status: state.groundingProtectionActive
         ? 'groundingProtection'
         : Number.isFinite(state.speedThroughWater) && state.speedThroughWater > 0 ? 'sailing' : 'waitingForPerformance',
       position: state.position,
       headingTrueDeg: radToDeg(state.headingTrue),
-      headingMagneticDeg: Number.isFinite(state.headingMagnetic) ? radToDeg(state.headingMagnetic) : null,
-      magneticVariationDeg: Number.isFinite(state.magneticVariation) ? radToDeg(state.magneticVariation) : null,
+      headingMagneticDeg: Number.isFinite(headingMagnetic) ? radToDeg(headingMagnetic) : null,
+      magneticVariationDeg: Number.isFinite(inputs.magneticVariation) ? radToDeg(inputs.magneticVariation) : null,
       courseOverGroundTrueDeg: radToDeg(state.courseOverGroundTrue),
       speedOverGround: state.speedOverGround,
       speedThroughWater: state.speedThroughWater,
@@ -404,10 +379,7 @@ module.exports = function createPlugin (app) {
           }
         : { status: publishesAnyWind() ? 'missing' : 'disabled' },
       inputs: {
-        autopilotMode: inputs.autopilotMode || null,
-        targetHeadingTrue: valueStatus(inputs.targetHeadingTrue),
-        targetHeadingMagnetic: valueStatus(inputs.targetHeadingMagnetic),
-        targetWindAngleApparent: valueStatus(inputs.targetWindAngleApparent),
+        turnRate: valueStatus(inputs.turnRate),
         magneticVariation: valueStatus(inputs.magneticVariation),
         performanceSpeed: valueStatus(inputs.polarSpeed),
         distanceToShore: valueStatus(inputs.distanceToShore),
@@ -486,6 +458,11 @@ function valueStatus (value) {
   return Number.isFinite(value) ? 'present' : 'missing'
 }
 
+function magneticHeadingFromTrue (headingTrue, magneticVariation) {
+  if (!Number.isFinite(headingTrue) || !Number.isFinite(magneticVariation)) return null
+  return wrap360Rad(headingTrue - magneticVariation)
+}
+
 function dateDistanceMs (date, now) {
   const time = new Date(date).getTime()
   if (!Number.isFinite(time)) return null

package/lib/plugin-schema.js

@@ -4,7 +4,7 @@ function buildSchema () {
   return {
     type: 'object',
     title: 'Sailboat Simulator',
-    description: 'Simulates a virtual sailboat from autopilot intent, polar performance, weather and optional shore-distance data already present in Signal K.',
+    description: 'Simulates a virtual sailboat from autopilot turn-rate output, polar performance, weather and optional shore-distance data already present in Signal K.',
     properties: {
       initialState: {
         type: 'object',
@@ -69,12 +69,12 @@ function buildSchema () {
       publishing: {
         type: 'object',
         title: 'Navigation output',
-        description: 'What it does: publishes the simulated boat navigation state. Requires: steering.autopilot target data to steer and performance.polarSpeed to move. Recommended providers: @signalk/signalk-autopilot, signalk-polar-performance-plugin and signalk-derived-data with navigation.magneticVariation publishing enabled for magnetic heading handling.',
+        description: 'What it does: publishes the simulated boat navigation state. Requires steering.autopilot.output.turnRate to steer and performance.polarSpeed to move. If navigation.magneticVariation is available, navigation.headingMagnetic is also published. Recommended providers: signalk-autopilot-emulator-v2, signalk-polar-performance-plugin and signalk-derived-data with navigation.magneticVariation publishing enabled.',
         properties: {
           navigation: {
             type: 'boolean',
             title: 'Publish navigation state',
-            description: 'Publishes navigation.position, navigation.headingTrue, navigation.headingMagnetic when available, navigation.courseOverGroundTrue, navigation.speedOverGround and navigation.speedThroughWater.',
+            description: 'Publishes navigation.position, navigation.headingTrue, navigation.headingMagnetic when magnetic variation is available, navigation.courseOverGroundTrue, navigation.speedOverGround and navigation.speedThroughWater.',
             default: true
           }
         }

package/lib/simulation-engine.js

@@ -2,7 +2,7 @@
 
 const { wrap180Rad, wrap360Rad } = require('./angles')
 const { destinationPoint } = require('./geo')
-const { apparentWindFromTrue, trueWindFromDirection } = require('./wind')
+const { trueWindFromDirection } = require('./wind')
 
 function createInitialState (options) {
   return {
@@ -11,8 +11,6 @@ function createInitialState (options) {
       longitude: options.initialState.longitude
     },
     headingTrue: wrap360Rad(options.initialState.headingTrue),
-    headingMagnetic: null,
-    magneticVariation: null,
     courseOverGroundTrue: wrap360Rad(options.initialState.headingTrue),
     speedOverGround: 0,
     speedThroughWater: 0,
@@ -31,27 +29,8 @@ function stepSimulation (state, inputs, options, now) {
     options.fallback.speedThroughWater,
     0
   ))
-  const windSteerHeadingTrue = inputs.autopilotMode === 'wind'
-    ? trueHeadingFromApparentWind({
-        targetWindAngleApparent: inputs.targetWindAngleApparent,
-        windDirectionTrue: inputs.windDirectionTrue,
-        trueWindSpeed: inputs.windSpeedTrue,
-        boatSpeed: requestedSpeedThroughWater
-      })
-    : null
-  const targetHeadingTrue = firstFinite(
-    windSteerHeadingTrue,
-    inputs.targetHeadingTrue,
-    trueHeadingFromMagnetic(inputs.targetHeadingMagnetic, inputs.magneticVariation),
-    state.headingTrue,
-    options.initialState.headingTrue
-  )
-  const headingTrue = approachHeading(
-    state.headingTrue,
-    targetHeadingTrue,
-    turnRateRadPerSecond(options),
-    stepSeconds
-  )
+  const turnRate = Number.isFinite(inputs.turnRate) ? inputs.turnRate : 0
+  const headingTrue = wrap360Rad(state.headingTrue + turnRate * stepSeconds)
   const groundingProtectionActive = shouldStopForGrounding(inputs, options, headingTrue)
   const speedThroughWater = groundingProtectionActive
     ? 0
@@ -64,8 +43,6 @@ function stepSimulation (state, inputs, options, now) {
   return {
     position,
     headingTrue: wrap360Rad(headingTrue),
-    headingMagnetic: magneticHeadingFromTrue(headingTrue, inputs.magneticVariation),
-    magneticVariation: Number.isFinite(inputs.magneticVariation) ? inputs.magneticVariation : null,
     courseOverGroundTrue: wrap360Rad(headingTrue),
     speedOverGround: speedThroughWater,
     speedThroughWater,
@@ -75,27 +52,6 @@ function stepSimulation (state, inputs, options, now) {
   }
 }
 
-function approachHeading (currentHeading, targetHeading, maxTurnRate, stepSeconds) {
-  if (!Number.isFinite(currentHeading) || !Number.isFinite(targetHeading)) return targetHeading
-  if (!Number.isFinite(maxTurnRate)) return wrap360Rad(targetHeading)
-  if (maxTurnRate <= 0 || stepSeconds <= 0) return wrap360Rad(currentHeading)
-
-  const delta = wrap180Rad(targetHeading - currentHeading)
-  const maxDelta = maxTurnRate * stepSeconds
-  if (Math.abs(delta) <= maxDelta) return wrap360Rad(targetHeading)
-
-  return wrap360Rad(currentHeading + Math.sign(delta) * maxDelta)
-}
-
-function turnRateRadPerSecond (options) {
-  if (!options.dynamics) return Infinity
-  if (Number.isFinite(options.dynamics.maxTurnRate)) return Math.max(0, options.dynamics.maxTurnRate)
-  if (Number.isFinite(options.dynamics.maxTurnRateDegPerSecond)) {
-    return Math.max(0, options.dynamics.maxTurnRateDegPerSecond) * Math.PI / 180
-  }
-  return Infinity
-}
-
 function shouldStopForGrounding (inputs, options, headingTrue) {
   const tooClose = Boolean(
     options.grounding &&
@@ -113,71 +69,6 @@ function isHeadingAwayFromShore (headingTrue, shoreBearingTrue) {
   return Math.abs(wrap180Rad(headingTrue - shoreBearingTrue)) > Math.PI / 2
 }
 
-function trueHeadingFromMagnetic (headingMagnetic, magneticVariation) {
-  if (!Number.isFinite(headingMagnetic) || !Number.isFinite(magneticVariation)) return null
-  return wrap360Rad(headingMagnetic + magneticVariation)
-}
-
-function magneticHeadingFromTrue (headingTrue, magneticVariation) {
-  if (!Number.isFinite(headingTrue) || !Number.isFinite(magneticVariation)) return null
-  return wrap360Rad(headingTrue - magneticVariation)
-}
-
-function trueHeadingFromApparentWind ({
-  targetWindAngleApparent,
-  windDirectionTrue,
-  trueWindSpeed,
-  boatSpeed
-}) {
-  if (
-    !Number.isFinite(targetWindAngleApparent) ||
-    !Number.isFinite(windDirectionTrue) ||
-    !Number.isFinite(trueWindSpeed)
-  ) return null
-
-  const trueWindAngle = trueWindAngleFromApparent({
-    targetWindAngleApparent,
-    trueWindSpeed,
-    boatSpeed: Number.isFinite(boatSpeed) ? boatSpeed : 0
-  })
-  if (!Number.isFinite(trueWindAngle)) return null
-
-  return wrap360Rad(windDirectionTrue - trueWindAngle)
-}
-
-function trueWindAngleFromApparent ({
-  targetWindAngleApparent,
-  trueWindSpeed,
-  boatSpeed
-}) {
-  const awa = wrap180Rad(targetWindAngleApparent)
-  const tws = Math.max(0, trueWindSpeed)
-  const stw = Math.max(0, Number.isFinite(boatSpeed) ? boatSpeed : 0)
-
-  if (tws === 0) return null
-  if (stw === 0) return awa
-
-  const crosswind = stw * Math.sin(awa)
-  const discriminant = (tws * tws) - (crosswind * crosswind)
-  if (discriminant < 0) return awa
-
-  const apparentSpeed = (stw * Math.cos(awa)) + Math.sqrt(discriminant)
-  if (apparentSpeed <= 0) return awa
-
-  const trueForward = (apparentSpeed * Math.cos(awa)) - stw
-  const trueStarboard = apparentSpeed * Math.sin(awa)
-  const twa = Math.atan2(trueStarboard, trueForward)
-
-  const apparent = apparentWindFromTrue({
-    trueWindSpeed: tws,
-    trueWindAngle: twa,
-    boatSpeed: stw
-  })
-  if (!apparent) return awa
-
-  return twa
-}
-
 function deriveWindAngleTrueWater (windDirectionTrue, headingTrue) {
   return trueWindFromDirection(windDirectionTrue, headingTrue)
 }
@@ -189,8 +80,5 @@ function firstFinite (...values) {
 module.exports = {
   createInitialState,
   deriveWindAngleTrueWater,
-  magneticHeadingFromTrue,
-  stepSimulation,
-  trueHeadingFromApparentWind,
-  trueHeadingFromMagnetic
+  stepSimulation
 }

package/lib/state-store.js

@@ -48,8 +48,6 @@ function stateFromSimulation (state) {
       longitude: state.position.longitude
     },
     headingTrue: state.headingTrue,
-    headingMagnetic: state.headingMagnetic,
-    magneticVariation: state.magneticVariation,
     courseOverGroundTrue: state.courseOverGroundTrue,
     speedOverGround: state.speedOverGround,
     speedThroughWater: state.speedThroughWater
@@ -65,8 +63,6 @@ function applyPersistedState (state, persisted) {
       longitude: persisted.position.longitude
     },
     headingTrue: numberOr(persisted.headingTrue, state.headingTrue),
-    headingMagnetic: numberOr(persisted.headingMagnetic, state.headingMagnetic),
-    magneticVariation: numberOr(persisted.magneticVariation, state.magneticVariation),
     courseOverGroundTrue: numberOr(persisted.courseOverGroundTrue, state.courseOverGroundTrue),
     speedOverGround: numberOr(persisted.speedOverGround, 0),
     speedThroughWater: numberOr(persisted.speedThroughWater, 0),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "signalk-sailboat-simulator",
-  "version": "0.1.0",
-  "description": "Signal K plugin that simulates a sailing boat from heading, weather and polar performance data.",
+  "version": "0.2.0",
+  "description": "Signal K plugin that simulates a sailing boat from autopilot turn-rate output, weather and polar performance data.",
   "main": "index.js",
   "scripts": {
     "test": "node --test"
@@ -41,7 +41,7 @@
   "signalk": {
     "displayName": "Sailboat Simulator",
     "recommends": [
-      "@signalk/signalk-autopilot",
+      "signalk-autopilot-emulator-v2",
       "signalk-polar-performance-plugin",
       "signalk-derived-data",
       "@signalk/open-meteo-provider",