NmeaParser

NmeaParser is a library designed for reading and parsing NMEA data message streams. It is compatible with Windows Universal, Windows Desktop/.NET, and .NET for iOS and Android.

Supported Message Types

• GNSS: BOD, GGA, GLL, GNS, GSA, GST, GSV, RMB, RMA, RMC, RTE, VTG, ZDA
• Garmin Proprietary: PGRME, PGRMZ
• Trimble Laser Range Finder: PTNLA, PTNLB
• TruePulse Laser Range Finder: PLTIT

Key Capabilities

• Automatic Merging: Multi-sentence messages are automatically merged for easier consumption.
• Extensibility: Supports custom NMEA messages.
• Input Device Support:
  • System.IO.Stream (all platforms)
  • NMEA log file emulation (all platforms)
  • Serial Device (.NET Framework, .NET Core on Windows/Linux/Mac, and Windows Universal)
  • Bluetooth (Windows Universal and Android; .NET Core/.NET Framework can use Bluetooth via SerialPortDevice)

NMEA messages often arrive in bursts. Instead of parsing individual messages manually, use the NmeaParser.Gnss.GnssMonitor class to aggregate multiple NMEA messages into a single, robust location event. This approach provides access to combined data from multiple satellite systems and more complete information (like altitude and accuracy).

Key Advantages:

• Aggregation: Combines fragmented NMEA messages into a single state.
• Robustness: Provides HorizontalError, VerticalError, and FixTime.
• Lifecycle Management: You can configure the provider to automatically start and stop the underlying NmeaDevice when the ArcGIS data source starts or stops.

Implementation Details:

• Use the GnssMonitor.LocationChanged and GnssMonitor.LocationLost events to trigger updates in your LocationDataSource.
• When mapping GnssMonitor values to ArcGIS Location objects:
  • Velocity: Convert speed (typically knots) to meters per second (multiply by 0.51444444).
  • Position: Use m_gnssMonitor.Altitude with a WGS84 ellipsoid height if available, otherwise fallback to standard SpatialReferences.Wgs84.
  • Course: Since ArcGIS does not allow NaN for course, cache the lastCourse value to use as a fallback.

// Example of initializing the robust data source
public class NmeaLocationDataSource : Esri.ArcGISRuntime.Location.LocationDataSource
{
    private readonly GnssMonitor m_gnssMonitor;
    private readonly bool m_startStopDevice;

    public NmeaLocationDataSource(NmeaParser.NmeaDevice device, bool startStopDevice = true) 
        : this(new GnssMonitor(device), startStopDevice)
    { 
    }

    public NmeaLocationDataSource(NmeaParser.Gnss.GnssMonitor monitor, bool startStopDevice = true)
    {
        this.m_gnssMonitor = monitor;
        this.m_startStopDevice = startStopDevice;
    }
}

To display NMEA device data on an ArcGIS MapView, you can implement a custom LocationDataSource that listens to NmeaDevice.MessageReceived events. In a basic implementation, you typically look for NmeaParser.Messages.Rmc messages to extract latitude, longitude, speed, and course.

Note: ArcGIS Runtime has a limitation where course cannot be NaN. You should handle this by defaulting to 0 if the NMEA message provides an invalid course value.

Implementation Steps:

1. Inherit from Esri.ArcGISRuntime.Location.LocationDataSource.
2. Subscribe to the device.MessageReceived event in the constructor.
3. In the event handler, check if the message is an active Rmc message.
4. Call base.UpdateLocation(...) with a new Esri.ArcGISRuntime.Location.Location object.
5. Override OnStartAsync to call device.OpenAsync() and OnStopAsync to call device.CloseAsync().

NmeaParser.NmeaDevice device = new NmeaParser.NmeaFileDevice("NmeaSampleData.txt");
mapView.LocationDisplay.DataSource = new NmeaLocationProvider(device);
mapView.LocationDisplay.InitialZoomScale = 20000;
mapView.LocationDisplay.IsEnabled = true;

To interface with a Bluetooth device in a UWP environment, follow these steps:

1. Pair the device: Ensure your Bluetooth device is already paired with your Windows device.
2. Find the device: Use RfcommDeviceService.GetDeviceSelector(RfcommServiceId.SerialPort) and DeviceInformation.FindAllAsync to locate available serial port services.
3. Select the device: Filter the list of DeviceInformation objects (e.g., by name).
4. Initialize the parser: Use RfcommDeviceService.FromIdAsync to get the service, then instantiate NmeaParser.BluetoothDevice passing the rfcommService.
5. Handle messages: Subscribe to the MessageReceived event to process incoming NMEA data.
6. Open the connection: Call await rangeFinder.OpenAsync() to start receiving data.

// Get list of devices
string serialDeviceType = RfcommDeviceService.GetDeviceSelector(RfcommServiceId.SerialPort);
var devices = await DeviceInformation.FindAllAsync(serialDeviceType);

// Select device by name (e.g., TruePulse 360B Laser Range Finder)
var TruePulse360B = devices.Where(t => t.Name.StartsWith("TP360B-")).FirstOrDefault();

// Get service
RfcommDeviceService rfcommService = await RfcommDeviceService.FromIdAsync(TruePulse360B.Id);
if (rfcommService != null)
{
	var rangeFinder = new NmeaParser.BluetoothDevice(rfcommService);
	rangeFinder.MessageReceived += device_NmeaMessageReceived;
	await rangeFinder.OpenAsync();		
}

// ...

private void device_NmeaMessageReceived(object sender, NmeaParser.NmeaMessageReceivedEventArgs args)
{
   // called when a message is received
}

To parse NMEA data from a physical serial port in a .NET Framework environment, wrap a System.IO.Ports.SerialPort instance within an NmeaParser.SerialPortDevice.

Follow these steps:

1. Initialize a System.IO.Ports.SerialPort with the correct portname (e.g., "COM3") and baudrate (e.g., 9600).
2. Instantiate NmeaParser.SerialPortDevice by passing the serial port instance to its constructor.
3. Subscribe to the MessageReceived event to handle incoming NMEA messages.
4. Call OpenAsync() to begin listening for data.

Incoming messages are handled via the OnNmeaMessageReceived event handler, which provides NmeaParser.NmeaDevice as the sender and NmeaParser.NmeaMessageReceivedEventArgs containing the message data.

string portname = "COM3"; // Change to match the name of the port your device is connected to
int baudrate = 9600; // Change to the baud rate your device communicates at (usually specified in the manual)
var port = new System.IO.Ports.SerialPort(portname, baudrate);
var device = new NmeaParser.SerialPortDevice(port);

// Subscribe to the event
device.MessageReceived += OnNmeaMessageReceived;

// Start listening
device.OpenAsync();

// ...

private void OnNmeaMessageReceived(NmeaParser.NmeaDevice sender, NmeaParser.NmeaMessageReceivedEventArgs args)
{
   // called when a message is received
}