signalk-ais-navionics-converter 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 formifan2002
+
+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,318 @@
+# SignalK AIS to NMEA 0183 Converter
+
+A SignalK plugin that converts AIS vessel data to NMEA 0183 sentences and broadcasts them via TCP to clients like 'Navionics Boating App' or 'OpenCpn'. Optionally forwards AIS data to VesselFinder.com and integrates cloud vessel data from AISFleet.com.
+
+It is intended for vessels that do not have their own AIS receiver on board.
+
+IMPORTANT: The following are required for the plugin to function:
+  - a valid GPS position (visible in the SignalK Data Browser) in navigation.position
+  - MMSI of your own vessel maintained in SignalK server settings (Server → Settings)
+
+## Content
+
+- [Features](#features)
+- [Installation](#installation)
+- [Configuration Parameters](#configuration-parameters)
+  - [Basic Settings](#basic-settings)
+    - [TCP Port](#tcp-port)
+    - [Update Interval for Changed Vessels](#update-interval-for-changed-vessels)
+    - [Update Interval for Unchanged Vessels](#update-interval-for-unchanged-vessels)
+  - [Data Filtering](#data-filtering)
+    - [Skip Vessels Without Callsign](#skip-vessels-without-callsign)
+    - [Skip Vessels With Stale Data](#skip-vessels-with-stale-data)
+    - [Stale Data Threshold](#stale-data-threshold)
+    - [Timestamp Added to Ship Name](#timestamp-added-to-ship-name)
+  - [Speed Over Ground (SOG) Correction](#speed-over-ground-sog-correction)
+    - [Minimum SOG for Alarm](#minimum-sog-for-alarm)
+    - [Maximum Minutes Before SOG Set to Zero](#maximum-minutes-before-sog-set-to-zero)
+  - [VesselFinder Integration](#vesselfinder-integration)
+    - [Enable VesselFinder Forwarding](#enable-vesselfinder-forwarding)
+    - [VesselFinder Host](#vesselfinder-host)
+    - [VesselFinder UDP Port](#vesselfinder-udp-port)
+    - [VesselFinder Update Rate](#vesselfinder-update-rate)
+  - [AISFleet Cloud Integration](#aisfleet-cloud-integration)
+    - [Include Vessels from AISFleetcom](#include-vessels-from-aisfleetcom)
+    - [Radius for Cloud Vessels](#radius-for-cloud-vessels)
+  - [Debug Options](#debug-options)
+    - [Debug All Vessel Details](#debug-all-vessel-details)
+    - [Debug MMSI](#debug-mmsi)
+    - [Debug Stale](#Debug-stale)
+    - [Debug JSON](#debug-json)
+    - [Debug AIS](#debug-ais-data)
+    - [Debug corrected SOG](#debug-corrected-sog)
+- [How It Works](#how-it-works)
+  - [Data Flow](#data-flow)
+  - [Merge Logic](#merge-logic)
+  - [Client Connection Handling](#client-connection-handling)
+- [Usage with Navionics Boating App](#usage-with-navionics-boating-app)
+- [Usage with OpenCpn](#usage-with-openCpn)
+- [Troubleshooting](#troubleshooting)
+  - [No vessels appear in navigation app](#no-vessels-appear-in-navigation-app)
+  - [Vessels disappear after a while](#vessels-disappear-after-a-while)
+  - [False collision warnings](#false-collision-warnings)
+  - [Too manyfew vessels](#too-manyfew-vessels)
+- [Debug Logging](#debug-logging)
+- [Requirements](#requirements)
+- [License](#license)
+- [Author](#author)
+- [Contributing](#contributing)
+- [Changelog](#changelog)
+  - [Version 1.0.0](#version-100)
+
+## Features
+
+- **TCP Server**: Broadcasts NMEA 0183 AIS messages ([Type 1 - Position report](https://gpsd.gitlab.io/gpsd/AIVDM.html#_types_1_2_and_3_position_report_class_a) and [Type 5 - static and voyage related data](https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_5_static_and_voyage_related_data)) to connected clients
+- **Smart Update Logic**: 
+  - Sends updates immediately when vessel data changes
+  - Resends unchanged vessels periodically to prevent timeout in navigation apps
+  - Sends complete dataset to newly connected clients
+- **Cloud Integration**: Fetches nearby vessels from AISFleet.com API and merges with local AIS data
+- **Data Quality**:
+  - Filters stale data based on configurable age threshold
+  - Corrects invalid COG/Heading values (360° → 0°)
+  - Optionally sets SOG to 0 for vessels with outdated position data
+  - Adds timestamp suffix to vessel names with old position data
+- **VesselFinder.com Support**: Optional UDP forwarding of AIS Type 1 messages
+- **Flexible Filtering**: Skip vessels without callsign or valid identification
+- **Debug Options**: Detailed logging for specific MMSI or all vessels
+
+Warning: AIS data provided by this plugin can assist navigation. However, it never replaces the skipper's responsibility. I exclude any liability for damages resulting from the use of this plugin.
+
+## Installation
+
+1. Install via SignalK App Store 
+2. Restart SignalK server
+3. Configure the plugin in SignalK admin interface → Server → Plugin Config → AIS to NMEA 0183 converter for TPC clients (e.g. Navionics)
+
+## Configuration Parameters
+
+### Basic Settings
+
+#### TCP Port
+- **Default**: 10113
+- **Description**: Port for the NMEA 0183 TCP server. Configure your navigation app (e.g., Navionics, OpenCpn) to connect to this port.
+
+#### Update Interval for Changed Vessels
+- **Default**: 15 (seconds)
+- **Description**: How often to check for and send updates when vessel data changes. Lower values = more real-time updates but higher CPU usage.
+
+#### Update Interval for Unchanged Vessels
+- **Default**: 60 (seconds)
+- **Description**: How often to resend data for vessels that haven't changed. Important for apps like Navionics to prevent vessels from disappearing. Set to 0 to disable (not recommended).
+
+### Data Filtering
+
+#### Skip Vessels Without Callsign
+- **Default**: false
+- **Description**: When enabled, vessels without a callsign will not be transmitted.
+
+#### Skip Vessels With Stale Data
+- **Default**: true
+- **Description**: When enabled, vessels with outdated position data will not be transmitted.
+
+#### Stale Data Threshold
+- **Default**: 60 (minutes)
+- **Description**: Position data older than this threshold will be considered stale and filtered out (if "Skip Vessels With Stale Data" is enabled).
+
+#### Timestamp Added to Ship Name
+- **Default**: 5 (minutes, 0=disabled)
+- **Description**: Adds a timestamp suffix to the vessel name if position data is older than specified minutes. Format: `SHIPNAME MIN15`, `SHIPNAME HOUR2`, or `SHIPNAME DAY3`. Vessel names are truncated to 20 characters.
+
+### Speed Over Ground (SOG) Correction
+
+#### Minimum SOG for Alarm
+- **Default**: 0.2 (m/s)
+- **Description**: SOG values below this threshold will be set to 0. Used by the AIS encoder.
+
+#### Maximum Minutes Before SOG Set to Zero
+- **Default**: 0 (minutes, 0=disabled)
+- **Description**: Automatically sets SOG to 0 for vessels whose position timestamp is older than specified minutes. Prevents false collision warnings in navigation apps for vessels with outdated data. Set to 0 to disable this feature.
+
+### VesselFinder Integration
+
+#### Enable VesselFinder Forwarding
+- **Default**: false
+- **Description**: When enabled, AIS Type 1 messages (position reports) are forwarded to VesselFinder.com via UDP.
+
+#### VesselFinder Host
+- **Default**: ais.vesselfinder.com
+- **Description**: Hostname for VesselFinder UDP server.
+
+#### VesselFinder UDP Port
+- **Default**: 5500
+- **Description**: UDP port for VesselFinder server.
+
+#### VesselFinder Update Rate
+- **Default**: 60 (seconds)
+- **Description**: How often to send position updates to VesselFinder.
+
+### AISFleet Cloud Integration
+
+#### Include Vessels from AISFleet.com
+- **Default**: true
+- **Description**: Fetches nearby vessels from AISFleet.com cloud API and merges them with local SignalK vessel data. Requires internet connection and own position.
+
+#### Radius for Cloud Vessels
+- **Default**: 10 (nm / nautical miles)
+- **Description**: Radius around own vessel position to fetch cloud vessels from AISFleet.com (1-100 nm).
+
+### Debug Options
+
+#### Debug All Vessel Details
+- **Default**: false
+- **Description**: Enables detailed debug logging for all vessels in the server log. Only visible when plugin is in debug mode. Useful for troubleshooting or understanding of send data.
+
+#### Debug MMSI
+- **Default**: empty
+- **Description**: MMSI number for detailed debug output of a specific vessel. Only visible when plugin is in debug mode. Leave empty to disable.
+
+#### Debug Stale
+- **Default**: false
+- **Description**: Stale vessels will be shown in debug log - only visible if plugin is in debug mode and debug all vessel details is enabled
+
+#### Debug JSON
+- **Default**: false
+- **Description**: JSON data of vessels will be shown in debug log - only visible if plugin is in debug mode and debug all vessel details is enabled
+
+#### Debug AIS data
+- **Default**: false
+- **Description**: Detailed debug AIS data output in server log for all vessels - only visible if plugin is in debug mode and debug all vessel details is enabled
+
+#### Debug corrected SOG
+- **Default**: false
+- **Description**: Detailed debug output in server log for all vessels with corrected SOG - only visible if plugin is in debug mode and debug all vessel details is enabled
+
+## How It Works
+
+### Data Flow
+
+1. **Data Collection**:
+   - Fetches vessel data from SignalK API (`http://<IP_OF_SIGNALK_SERVER>:<PORT_SIGNALK_SERVER>/signalk/v1/api/vessels`)
+     - use other SignalK plugins (like AisHub WS) to receive more vessels for SignalK with AIS information
+   - Optionally fetches nearby vessels from AISFleet.com API
+   - Merges both sources, preferring newer timestamps
+
+2. **Data Processing**:
+   - Filters out stale data based on age threshold
+   - Corrects invalid navigation values (COG 360° → 0°)
+   - Applies SOG correction for outdated positions
+   - Filters vessels without valid name AND callsign
+
+3. **NMEA Generation**:
+   - Creates AIS Type 1 messages (position reports)
+   - Creates AIS Type 5 messages (static vessel data)
+   - Encodes as NMEA 0183 sentences
+
+4. **Broadcasting**:
+   - Sends to all connected TCP clients
+   - Optionally forwards to VesselFinder.com via UDP
+   - Resends periodically to prevent client timeouts
+
+### Merge Logic
+
+When the same vessel exists in both SignalK and AISFleet cloud data:
+- **Position/Navigation**: Uses data with newer timestamp
+- **Name**: Prefers any non-"Unknown" value
+- **Callsign**: Prefers any non-empty value
+
+### Client Connection Handling
+
+When a new TCP client connects:
+- Complete dataset of all vessels is sent immediately
+- Client appears in "clients" count in logs
+- Ensures navigation app shows all vessels right away
+
+## Usage with Navionics Boating App
+
+1. Configure plugin with desired settings
+2. In Navionics app:
+   - Go to Menu → Connected devices
+     - Add new connection (via + sign in upper right corner)
+     - Enter name for the connection (e.g. SignalkAIS)
+     - Enter SignalK server IP address
+     - Enter configured TCP port (default: 10113 - same setting like in SignalK plugin)
+     - Select TCP (not UDP) 
+     - Save connection
+   - Go to Menu → Chart options → AIS settings 
+     - turn 'Display AIS targets' on
+3. Vessels should appear on chart immediately and in 'Connected devices' you should see as status for the connection: 'connected' (in green) and 'AIS data reception'
+
+## Usage with OpenCpn
+
+1. Configure plugin with desired settings
+2. In OpenCpn:
+   - Go to Menu → Tools → Options → Connections
+     - Add new connection as follows:
+         ![OpenCPN Screenshot1](img/OpenCpn1.png)
+         ![OpenCPN Screenshot2](img/OpenCpn2.png)
+     - Save connection
+   - Go to Menu → AIS 
+     - enable AIS targets
+3. Vessels should appear on chart immediately 
+
+## Troubleshooting
+
+### No vessels appear in navigation app
+- Check that plugin is enabled and TCP server is running
+- Verify TCP port in app matches plugin configuration
+- Check firewall settings on SignalK server
+- Enable debug logging to see if vessels are being sent
+
+### Vessels disappear after a while
+- Increase "Update Interval for Unchanged Vessels" (recommended: 60 seconds)
+- Check if "Skip Vessels With Stale Data" is filtering out vessels
+- Increase "Stale Data Threshold" if needed
+
+### False collision warnings
+- Enable "Maximum Minutes Before SOG Set to Zero"
+- Set appropriate threshold (e.g., 5-10 minutes)
+- This prevents CPA calculations for vessels with outdated position
+
+### Too many/few vessels
+- Adjust "Stale Data Threshold" to filter outdated vessels
+- Enable/disable "Include Vessels from AISFleet.com"
+- Adjust "Radius for Cloud Vessels" to control area coverage
+
+## Debug Logging
+
+To enable debug output:
+1. In SignalK admin interface: Server → Settings → Logging
+2. Change setting for plugin  `AIS to NMEA 0183 converter for TPC clients (e.g. Navionics)` to debug logging
+3. Restart SignalK
+4. Check logs in Server → Logs
+
+Debug information includes:
+- Number of vessels sent/unchanged
+- Connected clients count
+- Vessel filtering reasons
+- AIS sentence output (when Debug MMSI is set)
+
+## Requirements
+
+- SignalK server (Node.js version)
+- Own vessel position (for AISFleet cloud integration)
+- Own vessel MMSI
+- Internet connection (for AISFleet cloud features)
+- Navigation app with NMEA 0183 TCP support (e.g. Navionics boating app or OpenCpn)
+
+## License
+
+MIT
+
+## Author
+
+Dirk Behrendt
+
+## Contributing
+
+Issues and pull requests are welcome!
+
+## Changelog
+
+### Version 1.0.0
+- Initial release
+- TCP server for NMEA 0183 AIS broadcasting
+- SignalK and AISFleet cloud data integration
+- VesselFinder.com UDP forwarding
+- Smart filtering and data correction
+- Configurable update intervals

package/ais-encoder.js

@@ -0,0 +1,222 @@
+class AISEncoder {
+  static encode6bit(val) {
+    if (val < 0 || val > 63) throw new Error("6-bit out of range: " + val);
+    return val <= 39 ? String.fromCharCode(val + 48) : String.fromCharCode(val + 56);
+  }
+
+  static toTwosComplement(value, bits) {
+    if (value < 0) value = (1 << bits) + value;
+    return value;
+  }
+
+  static textToSixBit(str, length) {
+    const table = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_ !"#$%&\'()*+,-./0123456789:;<=>?';
+    let bits = '';
+    str = str || '';
+    for (let i = 0; i < length; i++) {
+      let c = i < str.length ? str[i].toUpperCase() : '@';
+      let idx = table.indexOf(c);
+      if (idx < 0) idx = 0;
+      bits += idx.toString(2).padStart(6, '0');
+    }
+    return bits;
+  }
+
+  static callsignToSixBit(callsign) {
+    callsign = (callsign || '').trim().toUpperCase();
+    const padded = callsign.padEnd(7, '@').substring(0, 7);
+    return this.textToSixBit(padded, 7);
+  }
+
+  static bitsToPayload(bits) {
+    let payload = '';
+    while (bits.length % 6 !== 0) {
+      bits += '0';
+    }
+    
+    for (let i = 0; i < bits.length; i += 6) {
+      let chunk = bits.substring(i, i + 6);
+      let val = parseInt(chunk, 2);
+      payload += this.encode6bit(val);
+    }
+    return payload;
+  }
+
+  static calculateChecksum(nmea) {
+    let cs = 0;
+    for (let i = 1; i < nmea.length; i++) cs ^= nmea.charCodeAt(i);
+    return cs.toString(16).toUpperCase().padStart(2, '0');
+  }
+
+  static createPositionReport(vessel, config) {
+    try {
+      const mmsi = parseInt(vessel.mmsi);
+      if (!mmsi || mmsi === 0) return null;
+
+      const nav = vessel.navigation || {};
+      const pos = nav.position?.value || nav.position || {};
+      const latitude = pos.latitude;
+      const longitude = pos.longitude;
+      if (latitude === undefined || longitude === undefined) return null;
+
+      const state = nav.state?.value || '';
+      let navStatus = 15;
+      const stateMap = {
+        'motoring': 0, 'anchored': 1, 'not under command': 2, 'restricted maneuverability': 3,
+        'constrained by draft': 4, 'moored': 5, 'aground': 6, 'fishing': 7,
+        'sailing': 8, 'hazardous material high speed': 9, 'hazardous material wing in ground': 10,
+        'power-driven vessel towing astern': 11, 'power-driven vessel pushing ahead': 12,
+        'reserved': 13, 'ais-sart': 14, 'undefined': 15
+      };
+      if (state && stateMap[state] !== undefined) navStatus = stateMap[state];
+
+      const timestamp = 60;
+      const raim = 0;
+      const maneuver = 0;
+      
+      const rateOfTurn = nav.rateOfTurn?.value || 0;
+      let rot = -128;
+      if (rateOfTurn !== 0) {
+        rot = Math.round(rateOfTurn * 4.733 * Math.sqrt(Math.abs(rateOfTurn)));
+        rot = Math.max(-126, Math.min(126, rot));
+      }
+      
+      const sog = nav.speedOverGround?.value || nav.speedOverGround || 0;
+      const cog = nav.courseOverGroundTrue?.value || nav.courseOverGroundTrue || 0;
+      const heading = nav.headingTrue?.value || nav.headingTrue || 0;
+
+      let sogValue = typeof sog === 'number' ? sog : 0;
+      if (sogValue < config.minAlarmSOG) sogValue = 0;
+
+      const cogValue = typeof cog === 'object' ? 0 : (typeof cog === 'number' ? cog : 0);
+      const headingValue = typeof heading === 'object' ? 0 : (typeof heading === 'number' ? heading : 0);
+
+      const lon = Math.round(longitude * 600000);
+      const lat = Math.round(latitude * 600000);
+      
+      const sogKnots = sogValue * 1.94384;
+      const sog10 = Math.round(sogKnots * 10);
+      
+      const cogDegrees = cogValue * 180 / Math.PI;
+      let cog10;
+      if (sogKnots < config.minAlarmSOG) {
+        cog10 = 0; // or 3600 to indicate not available
+      } else {
+        cog10 = Math.round(cogDegrees * 10);
+      }
+      
+      const headingDegrees = headingValue * 180 / Math.PI;
+      const headingInt = Math.round(headingDegrees);
+
+      let bits = '';
+      bits += (1).toString(2).padStart(6, '0');
+      bits += (0).toString(2).padStart(2, '0');
+      bits += mmsi.toString(2).padStart(30, '0');
+      bits += navStatus.toString(2).padStart(4, '0');
+      bits += this.toTwosComplement(rot, 8).toString(2).padStart(8, '0');
+      bits += sog10.toString(2).padStart(10, '0');
+      bits += '0';
+      bits += this.toTwosComplement(lon, 28).toString(2).padStart(28, '0');
+      bits += this.toTwosComplement(lat, 27).toString(2).padStart(27, '0');
+      bits += cog10.toString(2).padStart(12, '0');
+      bits += headingInt.toString(2).padStart(9, '0');
+      bits += timestamp.toString(2).padStart(6, '0');
+      bits += maneuver.toString(2).padStart(2, '0');
+      bits += '000';
+      bits += raim.toString();
+      bits += '0000000000000000000';
+
+      return this.bitsToPayload(bits);
+    } catch (error) {
+      console.error('Error creating position report:', error);
+      return null;
+    }
+  }
+
+  static createStaticVoyage(vessel) {
+    try {
+      const mmsi = parseInt(vessel.mmsi);
+      if (!mmsi || mmsi === 0) return null;
+
+      const design = vessel.design || {};
+      const length = design.length?.value?.overall || 0;
+      const beam = design.beam?.value || 0;
+      const draft = design.draft?.value?.maximum || 0;
+      const shipType = design.aisShipType?.value?.id || 0;
+      
+      const imo = parseInt(vessel.imo) || 0;
+      const aisVersion = 0;
+      
+      const ais = vessel.sensors?.ais || {};
+      const fromBow = ais.fromBow?.value || 0;
+      const fromCenter = ais.fromCenter?.value || 0;
+      
+      const toBow = Math.round(fromBow);
+      const toStern = Math.round(Math.max(0, length - fromBow));
+      const toPort = Math.round(Math.max(0, beam / 2 - fromCenter));
+      const toStarboard = Math.round(Math.max(0, beam / 2 + fromCenter));
+
+      let epfd = 1;
+      const positionSource = vessel.navigation?.position?.$source || '';
+      if (positionSource.includes('gps')) epfd = 1;
+      else if (positionSource.includes('gnss')) epfd = 1;
+      else if (positionSource.includes('glonass')) epfd = 2;
+      else if (positionSource.includes('galileo')) epfd = 3;
+
+      const destination = vessel.navigation?.destination?.commonName?.value || '';
+      const etaString = vessel.navigation?.courseGreatCircle?.activeRoute?.estimatedTimeOfArrival?.value || '';
+      
+      let etaMonth = 0, etaDay = 0, etaHour = 24, etaMinute = 60;
+      if (etaString && etaString !== '00-00T00:00Z' && etaString !== '00-00T24:60Z') {
+        const etaMatch = etaString.match(/(\d+)-(\d+)T(\d+):(\d+)/);
+        if (etaMatch) {
+          etaMonth = parseInt(etaMatch[1]) || 0;
+          etaDay = parseInt(etaMatch[2]) || 0;
+          etaHour = parseInt(etaMatch[3]) || 24;
+          etaMinute = parseInt(etaMatch[4]) || 60;
+        }
+      }
+      
+      const draughtDecimeters = Math.round(draft * 10);
+      const dte = 0;
+
+      let bits = '';
+      bits += (5).toString(2).padStart(6,'0');
+      bits += (0).toString(2).padStart(2,'0');
+      bits += mmsi.toString(2).padStart(30,'0');
+      bits += aisVersion.toString(2).padStart(2,'0');
+      bits += imo.toString(2).padStart(30,'0');
+      bits += this.callsignToSixBit(vessel.callSign ?? '');
+      bits += this.textToSixBit(vessel.name ?? '', 20);
+      bits += shipType.toString(2).padStart(8,'0');
+      bits += toBow.toString(2).padStart(9,'0');
+      bits += toStern.toString(2).padStart(9,'0');
+      bits += toPort.toString(2).padStart(6,'0');
+      bits += toStarboard.toString(2).padStart(6,'0');
+      bits += epfd.toString(2).padStart(4,'0');
+      bits += etaMonth.toString(2).padStart(4,'0');
+      bits += etaDay.toString(2).padStart(5,'0');
+      bits += etaHour.toString(2).padStart(5,'0');
+      bits += etaMinute.toString(2).padStart(6,'0');
+      bits += draughtDecimeters.toString(2).padStart(8,'0');
+      bits += this.textToSixBit(destination, 20);
+      bits += dte.toString(2);
+      bits += '0';
+
+      return this.bitsToPayload(bits);
+    } catch(err) {
+      console.error('Error creating type5:', err);
+      return null;
+    }
+  }
+
+  static createNMEASentence(payload, fragmentCount=1, fragmentNum=1, messageId=null, channel='B') {
+    const msgId = messageId !== null ? messageId.toString() : '';
+    const fillBits = (6 - (payload.length*6)%6)%6;
+    const sentence = `AIVDM,${fragmentCount},${fragmentNum},${msgId},${channel},${payload},${fillBits}`;
+    const checksum = this.calculateChecksum('!' + sentence);
+    return `!${sentence}*${checksum}`;
+  }
+}
+
+module.exports = AISEncoder;