signalk-autopilot-furuno 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- PGN 127237 (Heading/Track Control) listener for autopilot feedback and alarms
+- Alarm monitoring for autopilot limit exceeded conditions:
+  - Rudder limit exceeded
+  - Off heading limit exceeded
+  - Off track limit exceeded
+  - Autopilot override active
+- Commanded rudder angle logging from autopilot
+- Debug logging for all received PGN 127237 messages to troubleshoot data reception
+
+### Changed
+- Renamed 'route' mode to 'nav' mode for clearer navigation terminology
+- Simplified autopilot modes to focus on core functionality (standby, auto, nav)
+- `tack()` and `gybe()` methods now throw errors indicating they are not supported
+- Added alarms array to autopilot state for Signal K alarm integration
+
+### Removed
+- Removed 'wind' mode (not supported by Furuno NavPilot-711C)
+- Removed 'fishingPattern' mode (not supported by Furuno NavPilot-711C)
+- Removed `setWindAngle()`, `tack()`, and `gybe()` implementation from N2KCommands
+
+### Fixed
+- Fixed Signal K AutopilotProvider API compliance by keeping `tack()` and `gybe()` method stubs
+
+## [0.0.1] - Initial Release
+
+### Added
+- Initial implementation of Furuno NavPilot-711C autopilot provider
+- Support for autopilot modes: standby, auto, nav
+- NMEA2000 command interface via proprietary PGN 130850
+- Signal K path subscriptions for heading, rudder angle, and cross-track error
+- Autopilot detection and status reporting
+- Configuration options for device ID, hull type, and detection timeout

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SignalK Community
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# signalk-autopilot-furuno
+
+Signal K Autopilot Provider plugin for the Furuno NavPilot (700/711C) via NMEA 2000.
+
+Status: **feedback works; remote command is unverified.** This plugin reports the
+NavPilot's live state to Signal K and can act as a feedback provider. Remote command
+is disabled by default — see "Remote command" below.
+
+## What works
+
+- **Mode feedback** from PGN 127237 `Steering Mode`:
+  `Main Steering` → standby, `Heading Control Standalone` → auto, `Track Control` → nav.
+- **Rudder / heading feedback** from PGN 127245 / 127237.
+- **Route following (nav mode):** the NavPilot follows an active route on its own from the
+  standard route PGNs (129285 / 129284 / 129283). To command a GOTO from Signal K, emit those
+  as an active route source — use https://github.com/dirkwa/signalk-to-nmea2000.
+
+## Remote command (experimental, off by default)
+
+Remote command of this NavPilot over NMEA 2000 is **unverified**. The plugin can emit
+Furuno-proprietary command PGNs (126720 for mode, 130827 for course), but they are unproven
+and may do nothing, so they are gated behind the `experimentalCommands` setting and disabled by
+default. The Simrad PGN 130850 an earlier version used is inert, and the standard PGN 126208 is
+ignored by the pilot. "Adjust ±N°" is sent as an absolute course (there is no relative-course PGN).
+
+
+# Known Limitations
+
+## WIND-Mode
+- Furuno FAP-7002 does not support wind mode remote
+https://www.furuno.it/docs/OPERATOR_MANUAL/OME45120D_TZT9F_12F_16F_19F.pdf

package/doc/TZ_goto_mode.md

@@ -0,0 +1,84 @@
+
+# TZ Pro 4.x sents in goto:
+
+{
+  "pgn": 129285,
+  "prio": 6,
+  "src": 4,
+  "dst": 255,
+  "timestamp": "2025-11-15T22:32:21.673Z",
+  "description": "Navigation - Route/WP Information",
+  "fields": {
+    "startRps": null,
+    "nitems": 2,
+    "databaseId": 0,
+    "routeId": null,
+    "navigationDirectionInRoute": "Forward",
+    "supplementaryRouteWpDataAvailable": "Off",
+    "reserved": null,
+    "routeName": null,
+    "reserved9": null,
+    "list": [
+      {
+        "wpId": null,
+        "wpName": null,
+        "wpLatitude": -17.6814665,
+        "wpLongitude": 177.3838499
+      },
+      {
+        "wpId": 1,
+        "wpName": "WPT001",
+        "wpLatitude": -17.6936884,
+        "wpLongitude": 177.3707721
+      }
+    ]
+  },
+  "id": "navigationRouteWpInformation"
+}
+
+{
+  "pgn": 129284,
+  "prio": 3,
+  "src": 4,
+  "dst": 255,
+  "timestamp": "2025-11-15T22:32:31.125Z",
+  "description": "Navigation Data",
+  "fields": {
+    "sid": 127,
+    "distanceToWaypoint": 1934.78,
+    "courseBearingReference": "True",
+    "perpendicularCrossed": "No",
+    "arrivalCircleEntered": "No",
+    "calculationType": "Rhumbline",
+    "etaTime": null,
+    "etaDate": null,
+    "bearingOriginToDestinationWaypoint": 3.9396,
+    "bearingPositionToDestinationWaypoint": 3.9409,
+    "originWaypointNumber": null,
+    "destinationWaypointNumber": 1,
+    "destinationLatitude": -17.6936884,
+    "destinationLongitude": 177.3707721,
+    "waypointClosingVelocity": 0
+  },
+  "id": "navigationData"
+}
+
+{
+  "pgn": 129283,
+  "prio": 3,
+  "src": 4,
+  "dst": 255,
+  "timestamp": "2025-11-15T22:32:52.161Z",
+  "description": "Cross Track Error",
+  "fields": {
+    "sid": 147,
+    "xteMode": "Autonomous",
+    "reserved": null,
+    "navigationTerminated": "No",
+    "xte": -2.54,
+    "reserved6": null
+  },
+  "id": "crossTrackError"
+}
+
+

package/doc/install_beta.md

@@ -0,0 +1,43 @@
+Install master to RPI5, SK 2.18.0:
+# Install Latest bleading edge
+
+## Prerequirment - patched virtual analyzer to see transmitted PGNs
+```
+cd ~ && mkdir src && cd src
+git clone https://github.com/dirkwa/visual-analyzer.git
+cd visual-analyzer 
+npm pack
+
+cd ~/.signalk
+npm install ~/src/visual-analyzer/visual-analyzer-1.19.2.tgz
+```
+
+## Prerequirement - patched sifnalk-to-nmea2000
+```
+cd ~/src
+git clone https://github.com/dirkwa/signalk-to-nmea2000.git
+cd signalk-to-nmea2000
+npm pack
+
+cd ~/.signalk
+npm install ~/src/signalk-to-nmea2000/signalk-to-nmea2000-2.23.0.tgz
+```
+
+## signalk-autopilot-furuno
+```
+cd ~/src
+git clone https://github.com/dirkwa/signalk-autopilot-furuno.git
+cd signalk-autopilot-furuno/
+npm pack
+
+cd ~/.signalk
+npm install ~/src/signalk-autopilot-furuno/signalk-autopilot-furuno-0.0.1.tgz
+```
+
+## Restart Signal K
+```
+sudo systemctl restart signalk.service  && journalctl -u signalk -f | grep -i furuno
+```
+
+
+

package/index.js

@@ -0,0 +1,106 @@
+/**
+ * Signal K Plugin for Furuno NavPilot-711C Autopilot
+ * Main entry point
+ */
+
+const AutopilotProvider = require('./lib/AutopilotProvider')
+
+module.exports = function(app) {
+  const plugin = {
+    id: 'signalk-autopilot-furuno',
+    name: 'Furuno NavPilot-711C Autopilot Provider',
+    description: 'Signal K Autopilot Provider for Furuno NavPilot-711C via NMEA2000'
+  }
+
+  let autopilotProvider = null
+
+  plugin.start = function(settings) {
+    try {
+      app.debug('Starting Furuno NavPilot-711C plugin')
+      
+      autopilotProvider = new AutopilotProvider(app, settings)
+      autopilotProvider.start()
+      
+      app.setPluginStatus('Started')
+    } catch (error) {
+      const errorMsg = 'Failed to start: ' + error.message
+      app.error(errorMsg)
+      app.setPluginError(errorMsg)
+      throw error
+    }
+  }
+
+  plugin.stop = function() {
+    try {
+      app.debug('Stopping Furuno NavPilot-711C plugin')
+      
+      if (autopilotProvider) {
+        autopilotProvider.stop()
+        autopilotProvider = null
+      }
+      
+      app.setPluginStatus('Stopped')
+    } catch (error) {
+      app.error('Error stopping: ' + error.message)
+    }
+  }
+
+  plugin.schema = {
+    type: 'object',
+    required: ['deviceId'],
+    properties: {
+      deviceId: {
+        type: 'string',
+        title: 'Autopilot Device ID',
+        description: 'Unique identifier for this autopilot',
+        default: '711c'
+      },
+      hullType: {
+        type: 'string',
+        title: 'Hull Type',
+        description: 'Type of vessel hull for autopilot tuning',
+        enum: [
+          'sail',
+          'sailSlowTurn',
+          'sailCatamaran',
+          'power',
+          'powerSlowTurn',
+          'powerFastTurn'
+        ],
+        default: 'power'
+      },
+      detectionTimeout: {
+        type: 'number',
+        title: 'Detection Timeout (seconds)',
+        description: 'How long to wait for autopilot detection before showing warning',
+        default: 10
+      },
+      connectionTimeout: {
+        type: 'number',
+        title: 'Connection Timeout (seconds)',
+        description:
+          'If no autopilot data (PGN 127237) is received for this long, raise a ' +
+          '"NavPilot connection lost" notification.',
+        default: 5
+      },
+      experimentalCommands: {
+        type: 'boolean',
+        title: 'Enable experimental remote commands (UNVERIFIED)',
+        description:
+          'Off by default. This NavPilot has no verified NMEA 2000 remote-control path; ' +
+          'commands use Furuno proprietary PGNs (126720 mode / 130827 course) that ' +
+          'are unproven and may do nothing. Leave disabled for a feedback-only provider.',
+        default: false
+      },
+      deviceAddress: {
+        type: 'number',
+        title: 'Autopilot N2K source address (optional)',
+        description:
+          'Source address of the NavPilot on the bus, used as the command destination when ' +
+          'experimental commands are enabled. Leave blank to broadcast.'
+      }
+    }
+  }
+
+  return plugin
+}

package/lib/AutopilotProvider.js

@@ -0,0 +1,521 @@
+/**
+ * AutopilotProvider - Implements Signal K Autopilot API
+ */
+
+const SignalKPaths = require('./SignalKPaths')
+const N2KCommands = require('./N2KCommands')
+
+const PLUGIN_ID = 'signalk-autopilot-furuno'
+
+// PGN 127237 "Steering Mode" reported by the NavPilot maps to the
+// Signal K autopilot mode/engaged/state:
+//   Standby (hand steering) -> "Main Steering"
+//   Auto (heading hold)     -> "Heading Control Standalone"
+//   Nav / GOTO              -> "Track Control"
+const FURUNO_STEERING_MODE = {
+  'Main Steering': { mode: 'standby', engaged: false, state: 'disabled' },
+  'Non-Follow-Up Device': { mode: 'standby', engaged: false, state: 'disabled' },
+  'Follow-Up Device': { mode: 'standby', engaged: false, state: 'disabled' },
+  'Heading Control Standalone': { mode: 'auto', engaged: true, state: 'enabled' },
+  'Heading Control': { mode: 'auto', engaged: true, state: 'enabled' },
+  'Track Control': { mode: 'nav', engaged: true, state: 'enabled' }
+}
+
+// Signal K server emits canboat Title-Case field names by default
+// (useCamelCompat defaults to false), but a camelCase pipeline is possible.
+// Read a PGN field tolerant of either spelling.
+function field(fields, ...names) {
+  for (const n of names) {
+    if (fields[n] !== undefined) return fields[n]
+  }
+  return undefined
+}
+
+class AutopilotProvider {
+  constructor(app, settings) {
+    this.app = app
+    this.settings = settings
+    this.deviceId = settings.deviceId || '711c'
+
+    this.state = {
+      state: 'disabled',
+      mode: 'standby',
+      target: 0,
+      engaged: false,
+      heading: null,
+      rudderAngle: null,
+      xte: null,
+      alarms: []
+    }
+
+    this.signalKPaths = new SignalKPaths(app, this.onPathUpdate.bind(this))
+    this.n2kCommands = new N2KCommands(app, {
+      experimentalCommands: settings.experimentalCommands === true,
+      deviceAddress: settings.deviceAddress
+    })
+    this.detectionTimeout = null
+    this.detected = false
+    this.detectedHeading = false
+    this.detectedRudder = false
+    this.n2kListener = null
+
+    // Feedback bookkeeping
+    this.activeAlarms = {} // alarm/notification path -> boolean, for edge-triggered emits
+    this.lastN2K = null // ms timestamp of the last PGN 127237
+    this.connectionLost = false
+    this.staleTimer = null
+    // No 127237 for this long (ms) => NavPilot connection considered lost.
+    this.staleTimeout = (settings.connectionTimeout || 5) * 1000
+  }
+
+  start() {
+    this.app.debug('Registering autopilot provider: ' + this.deviceId)
+
+    // Register with Signal K
+    this.app.registerAutopilotProvider(this.getProvider(), [this.deviceId])
+
+    // Subscribe to Signal K paths
+    this.signalKPaths.subscribe()
+
+    // Initialize N2K commands
+    this.n2kCommands.initialize()
+
+    // Listen for PGN 127237 (Heading/Track Control) from autopilot
+    this.setupN2KListener()
+
+    // Send initial state
+    this.updateSignalK()
+
+    // Set detection timeout
+    const timeout = (this.settings.detectionTimeout || 10) * 1000
+    this.detectionTimeout = setTimeout(() => {
+      if (!this.detected) {
+        this.app.setPluginStatus('Warning - No autopilot data detected. Check NMEA2000 connection.')
+        this.app.debug('No heading or rudder data received after ' + (timeout/1000) + ' seconds')
+      }
+    }, timeout)
+
+    // Connection watchdog: NavPilot broadcasts 127237 continuously, so a gap
+    // means it is off / disconnected.
+    this.staleTimer = setInterval(() => this.checkConnection(), 1000)
+
+    this.app.setPluginStatus('Started - Waiting for autopilot data...')
+  }
+
+  stop() {
+    if (this.detectionTimeout) {
+      clearTimeout(this.detectionTimeout)
+    }
+    if (this.staleTimer) {
+      clearInterval(this.staleTimer)
+      this.staleTimer = null
+    }
+
+    if (this.n2kListener) {
+      this.app.removeListener('N2KAnalyzerOut', this.n2kListener)
+      this.n2kListener = null
+    }
+
+    this.signalKPaths.unsubscribe()
+    this.app.debug('AutopilotProvider stopped')
+  }
+
+  setupN2KListener() {
+    this.n2kListener = (n2k) => {
+      // Listen for PGN 127237 (Heading/Track Control) from autopilot
+      if (n2k && n2k.pgn === 127237 && n2k.fields) {
+        this.handlePGN127237(n2k.fields)
+      }
+    }
+
+    this.app.on('N2KAnalyzerOut', this.n2kListener)
+    this.app.debug('Listening for PGN 127237 (Heading/Track Control)')
+  }
+
+  handlePGN127237(fields) {
+    // Process autopilot feedback from PGN 127237
+    this.app.debug('Received PGN 127237: ' + JSON.stringify(fields))
+
+    this.markConnectionAlive()
+
+    let changed = false
+
+    // Mode feedback: reflect the NavPilot's actual Steering Mode into Signal K
+    // so the head and Signal K stay in sync (Auto -> Standby at the head, etc.).
+    const steeringMode = field(fields, 'Steering Mode', 'steeringMode')
+    const mapped = FURUNO_STEERING_MODE[steeringMode]
+    if (mapped) {
+      if (this.state.mode !== mapped.mode ||
+          this.state.engaged !== mapped.engaged ||
+          this.state.state !== mapped.state) {
+        this.app.debug(
+          'Mode feedback: ' + steeringMode + ' -> mode=' + mapped.mode +
+          ' engaged=' + mapped.engaged + ' state=' + mapped.state
+        )
+        this.state.mode = mapped.mode
+        this.state.engaged = mapped.engaged
+        this.state.state = mapped.state
+        changed = true
+      }
+    } else if (steeringMode !== undefined) {
+      this.app.debug('Unmapped Steering Mode: ' + steeringMode)
+    }
+
+    // Target feedback: the pilot's own commanded course (Heading-To-Steer),
+    // so Signal K reflects what the NavPilot is actually steering to.
+    const hts = field(fields, 'Heading-To-Steer (Course)', 'headingToSteer')
+    if (hts !== null && hts !== undefined && hts !== this.state.target) {
+      this.state.target = hts
+      changed = true
+    }
+
+    if (changed) {
+      this.updateSignalK()
+    }
+
+    // Limit / override flags -> Signal K notifications (edge-triggered).
+    // Off-heading and off-track map to the standard autopilot alarm paths;
+    // rudder-limit and override have no standard path, so use a custom one.
+    this.setAlarm('heading',
+      field(fields, 'Off-Heading Limit Exceeded', 'offHeadingLimitExceeded') === 'Yes',
+      'Off heading limit exceeded', 'alarm')
+    this.setAlarm('xte',
+      field(fields, 'Off-Track Limit Exceeded', 'offTrackLimitExceeded') === 'Yes',
+      'Off track limit exceeded', 'alarm')
+    this.setNotification('rudderLimit',
+      field(fields, 'Rudder Limit Exceeded', 'rudderLimitExceeded') === 'Yes',
+      'Rudder limit exceeded', 'alarm')
+    this.setNotification('override',
+      field(fields, 'Override', 'override') === 'Yes',
+      'Autopilot override active', 'warn')
+
+    // Log commanded rudder angle if available
+    const commandedRudderAngle = field(fields, 'Commanded Rudder Angle', 'commandedRudderAngle')
+    if (commandedRudderAngle !== null && commandedRudderAngle !== undefined) {
+      const cmdRudderDeg = (commandedRudderAngle * 180 / Math.PI).toFixed(1)
+      this.app.debug('Autopilot commanding rudder: ' + cmdRudderDeg + '°')
+    }
+  }
+
+  // Emit a standard autopilot alarm (path is one of the SK autopilot alarm names:
+  // heading, xte, wind, waypointAdvance, waypointArrival, routeComplete).
+  setAlarm(apPath, active, message, level) {
+    if (this.activeAlarms[apPath] === active) return
+    this.activeAlarms[apPath] = active
+    this.app.autopilotUpdate(this.deviceId, {
+      alarm: {
+        path: apPath,
+        value: active
+          ? { state: level || 'alarm', message, method: ['visual', 'sound'] }
+          : { state: 'normal', message, method: [] }
+      }
+    })
+    this.app.debug((active ? 'ALARM ' : 'clear ') + apPath + ': ' + message)
+  }
+
+  // Emit a notification on a non-standard autopilot path (rudderLimit, override,
+  // connectionLost) that has no dedicated autopilot-API alarm name.
+  setNotification(subPath, active, message, level) {
+    if (this.activeAlarms[subPath] === active) return
+    this.activeAlarms[subPath] = active
+    this.app.handleMessage(PLUGIN_ID, {
+      updates: [
+        {
+          values: [
+            {
+              path: 'notifications.steering.autopilot.' + subPath,
+              value: active
+                ? { state: level || 'alarm', message, method: ['visual', 'sound'] }
+                : { state: 'normal', message, method: [] }
+            }
+          ]
+        }
+      ]
+    })
+    this.app.debug((active ? 'NOTIFY ' : 'clear ') + subPath + ': ' + message)
+  }
+
+  onPathUpdate(path, value) {
+    let wasDetected = this.detected
+    
+    if (path === 'heading') {
+      this.state.heading = value
+      if (!this.detectedHeading) {
+        this.detectedHeading = true
+        this.app.debug('Heading data detected')
+        this.checkDetection()
+      }
+    } else if (path === 'rudderAngle') {
+      this.state.rudderAngle = value
+      if (!this.detectedRudder) {
+        this.detectedRudder = true
+        this.app.debug('Rudder angle data detected')
+        this.checkDetection()
+      }
+    } else if (path === 'xte') {
+      this.state.xte = value
+    }
+    // Heading/rudder/xte are not published as autopilot attributes (they are
+    // already on standard paths), so no autopilotUpdate() is needed here.
+  }
+
+  checkDetection() {
+    // Consider autopilot detected if we have heading data
+    // Rudder is nice to have but not required (some autopilots don't report it)
+    if (this.detectedHeading && !this.detected) {
+      this.detected = true
+      
+      let status = 'Connected - Autopilot detected ('
+      if (this.detectedHeading) status += 'heading'
+      if (this.detectedRudder) status += ', rudder'
+      status += ')'
+      
+      this.app.setPluginStatus(status)
+      this.app.debug('Autopilot fully detected')
+      
+      if (this.detectionTimeout) {
+        clearTimeout(this.detectionTimeout)
+        this.detectionTimeout = null
+      }
+    }
+  }
+
+  updateSignalK() {
+    // Only the valid autopilot update attributes are published here. Heading and
+    // rudder angle are already on standard paths (navigation.*, steering.rudderAngle);
+    // alarms are emitted separately via setAlarm()/setNotification().
+    this.app.autopilotUpdate(this.deviceId, {
+      state: this.state.state,
+      mode: this.state.mode,
+      target: this.state.target,
+      engaged: this.state.engaged
+    })
+  }
+
+  // Record that the NavPilot is transmitting, and clear a connection-lost
+  // notification if one was raised.
+  markConnectionAlive() {
+    this.lastN2K = Date.now()
+    if (this.connectionLost) {
+      this.connectionLost = false
+      this.setNotification('connectionLost', false, 'NavPilot connection restored', 'alarm')
+      this.app.setPluginStatus('Connected - NavPilot data OK')
+    }
+  }
+
+  // Watchdog: if no PGN 127237 arrives within staleTimeout, flag the NavPilot as
+  // disconnected (it stops broadcasting when powered off / bus fault).
+  checkConnection() {
+    if (this.lastN2K === null || this.connectionLost) return
+    if (Date.now() - this.lastN2K > this.staleTimeout) {
+      this.connectionLost = true
+      this.setNotification('connectionLost', true, 'NavPilot connection lost', 'alarm')
+      this.app.setPluginStatus('Warning - NavPilot connection lost (no data)')
+      this.app.debug('No PGN 127237 for ' + (this.staleTimeout / 1000) + 's - connection lost')
+    }
+  }
+
+  // Signal K Autopilot Provider Interface
+  getProvider() {
+    return {
+      getData: async (apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        
+        return {
+          options: {
+            states: [
+              { name: 'enabled', engaged: true },
+              { name: 'disabled', engaged: false }
+            ],
+            modes: ['standby', 'auto', 'nav'],
+            // 'dodge' is the only supported action, and only when experimental
+            // commands are enabled (no verified command path otherwise).
+            actions: [
+              {
+                id: 'dodge',
+                name: 'Dodge',
+                available: this.n2kCommands.commandsEnabled && this.state.mode !== 'standby'
+              }
+            ]
+          },
+          state: this.state.state,
+          mode: this.state.mode,
+          target: this.state.target,
+          engaged: this.state.engaged
+        }
+      },
+
+      getState: async (apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        return this.state.state
+      },
+
+      setState: async (newState, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        
+        if (newState !== 'enabled' && newState !== 'disabled') {
+          throw new Error('Invalid state: ' + newState)
+        }
+
+        if (newState === 'disabled') {
+          this.requireCommands('Disable')
+        }
+
+        this.app.debug('setState: ' + this.state.state + ' -> ' + newState)
+        this.state.state = newState
+
+        if (newState === 'disabled') {
+          this.state.mode = 'standby'
+          this.state.engaged = false
+          this.n2kCommands.setMode('standby')
+        }
+
+        this.updateSignalK()
+      },
+
+      getMode: async (apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        return this.state.mode
+      },
+
+      setMode: async (mode, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+
+        const validModes = ['standby', 'auto', 'nav']
+        if (!validModes.includes(mode)) {
+          throw new Error('Invalid mode: ' + mode)
+        }
+        this.requireCommands('setMode')
+
+        this.app.debug('setMode: ' + this.state.mode + ' -> ' + mode)
+        this.state.mode = mode
+        this.state.engaged = mode !== 'standby'
+
+        if (mode !== 'standby') {
+          this.state.state = 'enabled'
+        }
+
+        this.n2kCommands.setMode(mode)
+        this.updateSignalK()
+      },
+
+      getTarget: async (apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        return this.state.target
+      },
+
+      setTarget: async (value, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        this.requireCommands('setTarget')
+
+        const degrees = (value * 180 / Math.PI).toFixed(1)
+        this.app.debug('setTarget: ' + degrees + '°')
+
+        this.state.target = value
+
+        if (this.state.mode === 'auto') {
+          this.n2kCommands.setCourse(value)
+        }
+
+        this.updateSignalK()
+      },
+
+      adjustTarget: async (adjustment, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        this.requireCommands('adjustTarget')
+
+        const oldTarget = this.state.target
+        this.state.target += adjustment
+        
+        // Normalize to 0-2π
+        while (this.state.target < 0) this.state.target += 2 * Math.PI
+        while (this.state.target >= 2 * Math.PI) this.state.target -= 2 * Math.PI
+
+        const oldDeg = (oldTarget * 180 / Math.PI).toFixed(1)
+        const newDeg = (this.state.target * 180 / Math.PI).toFixed(1)
+        const adjDeg = (adjustment * 180 / Math.PI).toFixed(1)
+        this.app.debug('adjustTarget: ' + oldDeg + '° -> ' + newDeg + '° (' + adjDeg + '°)')
+
+        // The NavPilot has no relative command: send the new absolute course.
+        if (this.state.mode === 'auto') {
+          this.n2kCommands.setCourse(this.state.target)
+        }
+
+        this.updateSignalK()
+      },
+
+      engage: async (apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        this.requireCommands('engage')
+
+        this.app.debug('Engaging autopilot')
+        this.state.engaged = true
+        this.state.state = 'enabled'
+        
+        if (this.state.mode === 'standby') {
+          this.state.mode = 'auto'
+          this.n2kCommands.setMode('auto')
+        }
+
+        this.updateSignalK()
+      },
+
+      disengage: async (apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        this.requireCommands('disengage')
+
+        this.app.debug('Disengaging autopilot')
+        this.state.engaged = false
+        this.state.mode = 'standby'
+        this.n2kCommands.setMode('standby')
+        
+        this.updateSignalK()
+      },
+
+      tack: async (direction, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        throw new Error('Tack not supported by Furuno NavPilot-711C')
+      },
+
+      gybe: async (direction, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        throw new Error('Gybe not supported by Furuno NavPilot-711C')
+      },
+
+      dodge: async (value, apDeviceId) => {
+        this.validateDeviceId(apDeviceId)
+        this.requireCommands('dodge')
+
+        const degrees = (value * 180 / Math.PI).toFixed(1)
+        this.app.debug('Dodge: ' + degrees + '°')
+
+        // No dodge PGN exists; send an absolute course offset from the current target.
+        const base = this.state.target != null ? this.state.target : (this.state.heading || 0)
+        let course = base + value
+        while (course < 0) course += 2 * Math.PI
+        while (course >= 2 * Math.PI) course -= 2 * Math.PI
+        this.n2kCommands.setCourse(course)
+      }
+    }
+  }
+
+  validateDeviceId(apDeviceId) {
+    if (apDeviceId !== this.deviceId && apDeviceId !== '_default') {
+      throw new Error('Unknown autopilot device: ' + apDeviceId)
+    }
+  }
+
+  // Remote command has no verified path on this hardware; refuse unless the
+  // user opted into the experimental (unverified) command support.
+  requireCommands(action) {
+    if (!this.n2kCommands.commandsEnabled) {
+      throw new Error(
+        action + ' is not available: this NavPilot has no verified NMEA 2000 ' +
+        'remote-control path (feedback only). Enable "experimentalCommands" in the ' +
+        'plugin settings to attempt it (unverified, may do nothing).'
+      )
+    }
+  }
+}
+
+module.exports = AutopilotProvider

package/lib/N2KCommands.js

@@ -0,0 +1,96 @@
+/**
+ * N2KCommands - EXPERIMENTAL remote command support for the Furuno NavPilot.
+ *
+ * ⚠️ Remote command is UNVERIFIED on real hardware and disabled by default.
+ *
+ * The NavPilot uses Furuno-proprietary PGNs for control, NOT the Simrad PGN
+ * 130850 an earlier version of this plugin used (which encodes empty and is
+ * ignored), nor the standard PGN 126208 (which the pilot drops):
+ *
+ *   - Mode:   PGN 126720 (Furuno, mfr 1855) - proprietary selectors + mode value
+ *   - Course: PGN 130827 (Furuno, mfr 1855) - absolute course to steer (0.0001 rad)
+ *
+ * "Adjust +N°" / dodge are not separate messages: send the new absolute course
+ * (currentCourse ± N).
+ *
+ * The mode value and 126720 field packing are not fully confirmed, canboatjs has
+ * no matching PGN definition yet (so these may encode empty), and the tested
+ * NavPilot exposes no remote-control enable. These commands are best-effort and
+ * may do nothing. Enable only for experimentation via `experimentalCommands`.
+ */
+
+// Candidate NavPilot mode values. UNVERIFIED - the wire encoding is not confirmed.
+const NAVPILOT_MODE = { standby: 0, auto: 1, nav: 2 }
+
+class N2KCommands {
+  constructor(app, options = {}) {
+    this.app = app
+    this.enabled = options.experimentalCommands === true
+    // Destination = the pilot's N2K source address if known, else broadcast.
+    this.dst = options.deviceAddress != null ? options.deviceAddress : 255
+  }
+
+  initialize() {
+    this.app.debug('N2K command interface initialized (experimental=' + this.enabled + ')')
+  }
+
+  get commandsEnabled() {
+    return this.enabled
+  }
+
+  send(pgn, label) {
+    if (!this.enabled) {
+      this.app.debug('Command suppressed (experimentalCommands disabled): ' + label)
+      return false
+    }
+    try {
+      // Emit as a JSON PGN object (nmea2000JsonOut), not the string channel.
+      this.app.emit('nmea2000JsonOut', pgn)
+      this.app.debug('Sent experimental command [' + label + ']: ' + JSON.stringify(pgn))
+      return true
+    } catch (err) {
+      this.app.error('Failed to send ' + label + ': ' + err.message)
+      return false
+    }
+  }
+
+  // Mode command - PGN 126720 (Furuno proprietary). UNVERIFIED.
+  setMode(mode) {
+    const modeValue = NAVPILOT_MODE[mode]
+    if (modeValue === undefined) {
+      this.app.debug('Unknown mode: ' + mode)
+      return false
+    }
+    const pgn = {
+      pgn: 126720,
+      dst: this.dst,
+      fields: {
+        'Manufacturer Code': 'Furuno',
+        'Industry Code': 'Marine Industry',
+        // Furuno proprietary selectors (field 4 = 8, field 5 = 1) + mode (field 6).
+        'Message ID': 8,
+        'Command': 1,
+        'Mode': modeValue
+      }
+    }
+    return this.send(pgn, 'mode=' + mode)
+  }
+
+  // Absolute course-to-steer command - PGN 130827 (Furuno proprietary). UNVERIFIED.
+  // courseRad is an absolute heading in radians.
+  setCourse(courseRad) {
+    const pgn = {
+      pgn: 130827,
+      dst: this.dst,
+      fields: {
+        'Manufacturer Code': 'Furuno',
+        'Industry Code': 'Marine Industry',
+        'Message ID': 8,
+        'Commanded Course': courseRad
+      }
+    }
+    return this.send(pgn, 'course=' + (courseRad * 180 / Math.PI).toFixed(1) + '°')
+  }
+}
+
+module.exports = N2KCommands

package/lib/SignalKPaths.js

@@ -0,0 +1,98 @@
+/**
+ * SignalKPaths - Subscribes to Signal K paths and monitors autopilot data
+ */
+
+class SignalKPaths {
+  constructor(app, onUpdate) {
+    this.app = app
+    this.onUpdate = onUpdate
+    this.subscriptions = []
+    this.lastHeading = null
+    this.lastRudder = null
+    this.lastXTE = null
+  }
+
+  subscribe() {
+    this.app.debug('Subscribing to Signal K paths...')
+    
+    // Subscribe to heading (try both magnetic and true)
+    this.subscribePath('navigation.headingMagnetic', 'heading')
+    this.subscribePath('navigation.headingTrue', 'heading')
+    
+    // Subscribe to rudder angle
+    this.subscribePath('steering.rudderAngle', 'rudderAngle')
+    
+    // Subscribe to XTE for route mode
+    this.subscribePath('navigation.courseGreatCircle.crossTrackError', 'xte')
+  }
+
+  subscribePath(path, dataType) {
+    try {
+      const unsubscribe = this.app.streambundle.getSelfBus(path).onValue((rawValue) => {
+        // Extract actual value (might be wrapped in {value: ...})
+        let value = rawValue
+        if (typeof rawValue === 'object' && rawValue !== null && 'value' in rawValue) {
+          value = rawValue.value
+        }
+
+        // Skip if value is null or undefined
+        if (value === null || value === undefined) {
+          return
+        }
+
+        // Throttle logging based on data type
+        let shouldLog = false
+        
+        if (dataType === 'heading') {
+          // Only log heading on significant change (>10 degrees) or first time
+          if (this.lastHeading === null || Math.abs(value - this.lastHeading) > 0.174) {
+            const degrees = (value * 180 / Math.PI).toFixed(1)
+            this.app.debug('Heading updated: ' + degrees + '°')
+            this.lastHeading = value
+            shouldLog = true
+          }
+        } else if (dataType === 'rudderAngle') {
+          // Only log rudder on significant change (>5 degrees) or first time
+          if (this.lastRudder === null || Math.abs(value - this.lastRudder) > 0.087) {
+            const degrees = (value * 180 / Math.PI).toFixed(1)
+            this.app.debug('Rudder angle: ' + degrees + '°')
+            this.lastRudder = value
+            shouldLog = true
+          }
+        } else if (dataType === 'xte') {
+          // Only log XTE on significant change (>10m) or first time
+          if (this.lastXTE === null || Math.abs(value - this.lastXTE) > 10) {
+            this.app.debug('Cross track error: ' + value.toFixed(1) + 'm')
+            this.lastXTE = value
+            shouldLog = true
+          }
+        }
+        
+        // Always call onUpdate, but only log occasionally
+        this.onUpdate(dataType, value)
+      })
+
+      this.subscriptions.push({ path, unsubscribe })
+      this.app.debug('Subscribed to: ' + path)
+    } catch (err) {
+      this.app.debug('Could not subscribe to ' + path + ': ' + err.message)
+    }
+  }
+
+  unsubscribe() {
+    this.subscriptions.forEach((sub) => {
+      try {
+        if (sub.unsubscribe && typeof sub.unsubscribe === 'function') {
+          sub.unsubscribe()
+          this.app.debug('Unsubscribed from: ' + sub.path)
+        }
+      } catch (err) {
+        this.app.debug('Error unsubscribing from ' + sub.path + ': ' + err.message)
+      }
+    })
+    
+    this.subscriptions = []
+  }
+}
+
+module.exports = SignalKPaths

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "signalk-autopilot-furuno",
+  "version": "0.1.0",
+  "description": "Signal K Autopilot Provider plugin for Furuno NavPilot (700/711C) via NMEA2000",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "lib/",
+    "doc/",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-category-autopilot",
+    "autopilot",
+    "furuno",
+    "navpilot",
+    "navpilot-711c"
+  ],
+  "author": "Dirk Wahrheit",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dirkwa/signalk-autopilot-furuno.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dirkwa/signalk-autopilot-furuno/issues"
+  },
+  "homepage": "https://github.com/dirkwa/signalk-autopilot-furuno#readme",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  }
+}