public void TestGpgns_NoData()
{
string input = "$GPGNS,235720.00,,,,,,6,,,,2.0,0*48";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Gns));
Gns gns = (Gns)msg;
Assert.AreEqual(Talker.GlobalPositioningSystem, gns.TalkerId);
Assert.AreEqual(new TimeSpan(0, 23, 57, 20, 0), gns.FixTime);
Assert.AreEqual(double.NaN, gns.Latitude);
Assert.AreEqual(double.NaN, gns.Longitude);
Assert.AreEqual(Gns.Mode.NoFix, gns.GpsModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.GlonassModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.GalileoModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.BDSModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.QZSSModeIndicator);
Assert.AreEqual(0, gns.ModeIndicators.Length);
Assert.AreEqual(6, gns.NumberOfSatellites);
Assert.AreEqual(double.NaN, gns.Hdop);
Assert.AreEqual(double.NaN, gns.OrhometricHeight);
Assert.AreEqual(double.NaN, gns.GeoidalSeparation);
Assert.AreEqual(TimeSpan.FromSeconds(2), gns.TimeSinceLastDgpsUpdate);
Assert.AreEqual("0", gns.DgpsStationId);
}
public void TestGngns()
{
string input = "$GNGNS,235719.00,3403.47068778,N,11711.80950154,W,DDNNN,10,1.4,402.411,-32.133,,*26";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Gns));
Gns gns = (Gns)msg;
Assert.AreEqual(Talker.GlobalNavigationSatelliteSystem, gns.TalkerId);
Assert.AreEqual(new TimeSpan(0, 23, 57, 19, 0), gns.FixTime);
Assert.AreEqual(34.0578447963333, gns.Latitude, .000000000001);
Assert.AreEqual(-117.196825025667, gns.Longitude, .00000000001);
Assert.AreEqual(Gns.Mode.Differential, gns.GpsModeIndicator);
Assert.AreEqual(Gns.Mode.Differential, gns.GlonassModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.GalileoModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.BDSModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.QZSSModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.NavICModeIndicator);
Assert.AreEqual(5, gns.ModeIndicators.Length);
Assert.AreEqual(Gns.Mode.Differential, gns.ModeIndicators[0]);
Assert.AreEqual(Gns.Mode.Differential, gns.ModeIndicators[1]);
Assert.AreEqual(Gns.Mode.NoFix, gns.ModeIndicators[2]);
Assert.AreEqual(Gns.Mode.NoFix, gns.ModeIndicators[3]);
Assert.AreEqual(Gns.Mode.NoFix, gns.ModeIndicators[4]);
Assert.AreEqual(10, gns.NumberOfSatellites);
Assert.AreEqual(1.4, gns.Hdop);
Assert.AreEqual(402.411, gns.OrhometricHeight);
Assert.AreEqual(-32.133, gns.GeoidalSeparation);
Assert.AreEqual(TimeSpan.MaxValue, gns.TimeSinceLastDgpsUpdate);
Assert.AreEqual(null, gns.DgpsStationId);
Assert.AreEqual(Gns.NavigationalStatus.NotValid, gns.Status);
}
public static object Parse(NmeaMessage message)
{
GSV gsv = new GSV
{
MessageCount = GpsUtils.ParseUshort(message.Payload[0]),
MessageNumber = GpsUtils.ParseUshort(message.Payload[1]),
VisibleSVCount = GpsUtils.ParseUshort(message.Payload[2]),
};
List<SatelliteInfo> satellites = new List<SatelliteInfo>();
int maxLen = Math.Min(19, message.Payload.Length);
for (int i = 3; i < maxLen; i+=4)
{
if (string.IsNullOrWhiteSpace(message.Payload[i]))
continue;
SatelliteInfo satellite = new SatelliteInfo();
satellite.SVPrnNumber = message.Payload[i];
satellite.ElevationDegrees = GpsUtils.ParseFloat(message.Payload[i + 1]);
satellite.Azimuth = GpsUtils.ParseFloat(message.Payload[i + 2]);
satellite.SNR = message.Payload[i + 3];
satellites.Add(satellite);
}
gsv.Satellites = satellites.ToArray();
return gsv;
}
public void TestGpgns()
{
string input = "$GPGNS,224749.00,3333.4268304,N,11153.3538273,W,D,19,0.6,406.110,-26.294,6.0,0138,S*6A";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Gns));
Gns gns = (Gns)msg;
Assert.AreEqual(new TimeSpan(0, 22, 47, 49, 0), gns.FixTime);
Assert.AreEqual(33.55711384, gns.Latitude, .000000000001);
Assert.AreEqual(-111.889230455, gns.Longitude, .000000000001);
Assert.AreEqual(Gns.Mode.Differential, gns.GpsModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.GlonassModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.GalileoModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.BDSModeIndicator);
Assert.AreEqual(Gns.Mode.NoFix, gns.QZSSModeIndicator);
Assert.AreEqual(1, gns.ModeIndicators.Length);
Assert.AreEqual(19, gns.NumberOfSatellites);
Assert.AreEqual(.6, gns.Hdop);
Assert.AreEqual(406.110, gns.OrhometricHeight);
Assert.AreEqual(-26.294, gns.GeoidalSeparation);
Assert.AreEqual("0138", gns.DgpsStationId);
Assert.AreEqual(Gns.NavigationalStatus.Safe, gns.Status);
Assert.AreEqual(TimeSpan.FromSeconds(6), gns.TimeSinceLastDgpsUpdate);
}
internal static void WriteToFile(NmeaMessage message, string path)
{
using (StreamWriter sw = File.AppendText(Path.Combine(path, $"{DateTime.Now.ToString("yyyyMMdd")}.txt")))
{
sw.WriteLine(message);
}
}
/// <summary>
/// Called when the message is being loaded.
/// </summary>
/// <param name="message">The NMEA message values.</param>
protected override void OnLoadMessage(string[] message)
{
if (message == null || message.Length < 14)
{
throw new ArgumentException("Invalid GPGGA", "message");
}
int fixQuality;
int numberOfSatellites;
Latitude = NmeaMessage.StringToLatitude(message[1], message[2]);
Longitude = NmeaMessage.StringToLongitude(message[3], message[4]);
Quality = int.TryParse(message[5], NumberStyles.Integer, CultureInfo.InvariantCulture, out fixQuality) ? (FixQuality)fixQuality : FixQuality.Invalid;
NumberOfSatellites = int.TryParse(message[6], NumberStyles.Integer, CultureInfo.InvariantCulture, out numberOfSatellites) ? numberOfSatellites : 0;
Hdop = NmeaMessage.StringToDouble(message[7]);
Altitude = NmeaMessage.StringToDouble(message[8]);
AltitudeUnits = message[9];
HeightOfGeoid = NmeaMessage.StringToDouble(message[10]);
HeightOfGeoidUnits = message[11];
TimeSinceLastDgpsUpdate = StringToTimeSpan(message[0]);
if (message[13].Length > 0)
{
DgpsStationId = int.Parse(message[13], CultureInfo.InvariantCulture);
}
else
{
DgpsStationId = -1;
}
}
private static void Run()
{
Console.ForegroundColor = ConsoleColor.Green;
TcpClient client = new TcpClient("153.44.253.27", 5631);
NetworkStream networkStream = client.GetStream();
StreamReader reader = new StreamReader(networkStream);
var nmeaList = new List <NmeaMessage>();
while (true)
{
string nmeaString = reader.ReadLine();
try
{
NmeaMessage nmeaMsg = AisDecoder.ParseNmea(nmeaString);
nmeaList.Add(nmeaMsg);
if (nmeaMsg.SentenceNumber == nmeaMsg.NumberOfSentences)
{
var aisMsg = AisDecoder.DecodeAis(nmeaList);
Console.WriteLine(aisMsg.ToString());
nmeaList.Clear();
}
}
catch (InvalidNmeaException e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(e.Message);
Console.ForegroundColor = ConsoleColor.Green;
}
}
}
public async Task ParseTrimbleR2NmeaFile()
{
#if NETFX_CORE
var file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///TrimbleR2SampleData.txt"));
System.IO.StreamReader reader = new System.IO.StreamReader(await file.OpenStreamForReadAsync());
#else
System.IO.StreamReader reader = new System.IO.StreamReader("TrimbleR2SampleData.txt");
#endif
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (line.StartsWith("$"))
{
var msg = NmeaMessage.Parse(line);
Assert.IsNotNull(msg);
var idx = line.IndexOf('*');
if (idx >= 0)
{
byte checksum = (byte)Convert.ToInt32(line.Substring(idx + 1), 16);
Assert.AreEqual(checksum, msg.Checksum);
}
if (msg.MessageType == "PTNL" || msg.MessageType == "GNVTG" || msg.MessageType == "GNZDA")
{
continue; //TODO
}
Assert.IsNotInstanceOfType(msg, typeof(Nmea.UnknownMessage), "Type " + msg.MessageType + " not supported");
}
}
}
public void TestGpgsa()
{
string input = "$GPGSA,M,2,19,28,14,18,27,22,31,39,40,42,43,44,1.7,1.0,1.3*3C";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Gsa));
Gsa gsa = (Gsa)msg;
Assert.AreEqual(Gsa.ModeSelection.Manual, gsa.Mode);
Assert.AreEqual(Gsa.FixType.Fix2D, gsa.Fix);
Assert.AreEqual(12, gsa.SatelliteIDs.Length);
Assert.AreEqual(19, gsa.SatelliteIDs[0]);
Assert.AreEqual(28, gsa.SatelliteIDs[1]);
Assert.AreEqual(14, gsa.SatelliteIDs[2]);
Assert.AreEqual(18, gsa.SatelliteIDs[3]);
Assert.AreEqual(27, gsa.SatelliteIDs[4]);
Assert.AreEqual(22, gsa.SatelliteIDs[5]);
Assert.AreEqual(31, gsa.SatelliteIDs[6]);
Assert.AreEqual(39, gsa.SatelliteIDs[7]);
Assert.AreEqual(40, gsa.SatelliteIDs[8]);
Assert.AreEqual(42, gsa.SatelliteIDs[9]);
Assert.AreEqual(43, gsa.SatelliteIDs[10]);
Assert.AreEqual(44, gsa.SatelliteIDs[11]);
Assert.AreEqual(1.7, gsa.Pdop);
Assert.AreEqual(1.0, gsa.Hdop);
Assert.AreEqual(1.3, gsa.Vdop);
}
public void MissingChecksum()
{
string input = "$GPRMA,A,4917.24,S,12309.57,W,1000.0,2000.0,123.4,321.0,10,E,A";
var msg = NmeaMessage.Parse(input);
Assert.IsNotNull(msg);
}
private void ProcessMessage(string p)
{
try
{
if (p.Length == 0 || p[0] != '$')
{
return;
}
var msg = NmeaMessage.Parse(p, _lastMultiMessage);
if (msg is IMultiSentenceMessage multi)
{
if (!multi.IsComplete)
{
_lastMultiMessage = multi; //Keep it around until next time
return;
}
}
_lastMultiMessage = null;
if (msg != null)
{
OnMessageReceived(msg);
}
}
catch { }
}
ParseNmeaFile()
{
#if NETFX_CORE
var file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///NmeaSampleData.txt"));
System.IO.StreamReader reader = new System.IO.StreamReader(await file.OpenStreamForReadAsync());
#else
System.IO.StreamReader reader = new System.IO.StreamReader("NmeaSampleData.txt");
#endif
NmeaMessage previousMessage = null;
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (line.StartsWith("$"))
{
var msg = NmeaMessage.Parse(line, previousMessage as IMultiSentenceMessage);
Assert.IsNotNull(msg);
var idx = line.IndexOf('*');
if (idx >= 0)
{
byte checksum = (byte)Convert.ToInt32(line.Substring(idx + 1), 16);
Assert.AreEqual(checksum, msg.Checksum);
}
Assert.IsNotInstanceOfType(msg, typeof(UnknownMessage), "Type " + msg.MessageType + " not supported");
}
}
}
public void TestGpgsv()
{
string input = "$GPGSV,3,3,11,22,42,067,42,75,14,311,43,50,05,244,00,,,,*49";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Gsv));
Gsv gsv = (Gsv)msg;
Assert.IsInstanceOfType(msg, typeof(IMultiSentenceMessage));
Assert.IsFalse(((IMultiSentenceMessage)msg).IsComplete);
Assert.AreEqual(11, gsv.SatellitesInView);
Assert.IsNotNull(gsv.SVs);
Assert.AreEqual(3, gsv.SVs.Count);
var sv = gsv.SVs[0];
Assert.AreEqual(22, sv.Id);
Assert.AreEqual(42, sv.Elevation);
Assert.AreEqual(67, sv.Azimuth);
Assert.AreEqual(42, sv.SignalToNoiseRatio);
Assert.AreEqual(SatelliteSystem.Gps, sv.System);
sv = gsv.SVs[1];
Assert.AreEqual(75, sv.Id);
Assert.AreEqual(14, sv.Elevation);
Assert.AreEqual(311, sv.Azimuth);
Assert.AreEqual(43, sv.SignalToNoiseRatio);
Assert.AreEqual(SatelliteSystem.Glonass, sv.System);
sv = gsv.SVs[2];
Assert.AreEqual(50, sv.Id);
Assert.AreEqual(5, sv.Elevation);
Assert.AreEqual(244, sv.Azimuth);
Assert.AreEqual(00, sv.SignalToNoiseRatio);
Assert.AreEqual(SatelliteSystem.Waas, sv.System);
}
public void TestCustomMessageDuplicateRegistrationFailure()
{
int count = NmeaMessage.RegisterAssembly(typeof(CustomMessage).Assembly, true);
Assert.AreEqual(2, count);
NmeaMessage.RegisterAssembly(typeof(CustomMessage).Assembly, false); // This will throw
}
/// <summary>
/// Called when the message is being loaded.
/// </summary>
/// <param name="message">The NMEA message values.</param>
protected override void OnLoadMessage(string[] message)
{
if (message == null || message.Length < 11)
{
throw new ArgumentException("Invalid GPRMC", "message");
}
if (message[8].Length == 6 && message[0].Length >= 6)
{
FixTime = new DateTime(int.Parse(message[8].Substring(4, 2), CultureInfo.InvariantCulture) + 2000,
int.Parse(message[8].Substring(2, 2), CultureInfo.InvariantCulture),
int.Parse(message[8].Substring(0, 2), CultureInfo.InvariantCulture),
int.Parse(message[0].Substring(0, 2), CultureInfo.InvariantCulture),
int.Parse(message[0].Substring(2, 2), CultureInfo.InvariantCulture),
0, DateTimeKind.Utc).AddSeconds(double.Parse(message[0].Substring(4), CultureInfo.InvariantCulture));
}
Active = (message[1] == "A");
Latitude = NmeaMessage.StringToLatitude(message[2], message[3]);
Longitude = NmeaMessage.StringToLongitude(message[4], message[5]);
Speed = NmeaMessage.StringToDouble(message[6]);
Course = NmeaMessage.StringToDouble(message[7]);
MagneticVariation = NmeaMessage.StringToDouble(message[9]);
if (!double.IsNaN(MagneticVariation) && message[10] == "W")
{
MagneticVariation *= -1;
}
}
private static void Uut_MessageReceived(object sender, EventArgs e)
{
NmeaDevice device = (NmeaDevice)sender;
NmeaMessage message = ((NmeaMessageReceivedEventArgs)e).Message;
Console.WriteLine(message.ToString());
list.Add(message);
}
public void Parse_InvalidNmeaString()
{
//The norwegian costal authority seems to send garbled messages these days.
NmeaMessage msg = NmeaParser.Parse("\\s:2573315,c:1606586568*09\\!BSVDM,1,1,,B,13nP7p?PAfPMiF2SmT=S4ROP0<1q,0*3E");
Assert.AreEqual("!BSVDM", msg.MessageType);
Assert.AreEqual("0*3E", msg.Checksum);
}
public static object Parse(NmeaMessage message)
{
VTG vtg = new VTG();
vtg.TrueTrackMadeGood = GpsUtils.ParseFloat(message.Payload[0]);
vtg.MagneticTrackMadeGood = GpsUtils.ParseFloat(message.Payload[2]);
vtg.GroundSpeedKnots = GpsUtils.ParseFloat(message.Payload[4]);
vtg.GroundSpeedKph = GpsUtils.ParseFloat(message.Payload[6]);
return vtg;
}
private void OnMessageReceived(NmeaMessage msg)
{
if (msg == null)
{
return;
}
MessageReceived?.Invoke(this, new NmeaMessageReceivedEventArgs(msg));
}
public void IgnoreChecksum()
{
string input = "$GPRMA,A,4917.24,S,12309.57,W,1000.0,2000.0,123.4,321.0,10,E,A*00";
var msg = NmeaMessage.Parse(input, ignoreChecksum: true);
Assert.IsNotNull(msg);
Assert.ThrowsException <ArgumentException>(() => NmeaMessage.Parse(input, ignoreChecksum: false));
}
void GpsStatus.INmeaListener.OnNmeaReceived(long timestamp, string?message)
#endif
{
_isNmeaSupported = true;
if (message != null)
{
NmeaMessage?.Invoke(this, message);
}
}
public static AisMessage DecodeAis(NmeaMessage nmeaMsg)
{
if (nmeaMsg.NumberOfSentences > 1)
{
throw new Exception("Multipart message. Use GetAisMessage(List<NmeaMessage>) instead");
}
return(AisParser.DecodeAisString(nmeaMsg.EncodedPayload));
}
public static object Parse(NmeaMessage message)
{
GLL gll = new GLL();
gll.Latitude = GpsUtils.DecodeCoordinate(message.Payload[0], message.Payload[1]);
gll.Longitude = GpsUtils.DecodeCoordinate(message.Payload[2], message.Payload[3]);
gll.FixTime = TimeSpan.ParseExact(message.Payload[4], "hhmmss\\.ff", CultureInfo.InvariantCulture);
gll.DataIsValid = message.Payload[5] == "A";
return gll;
}
public void TestGpzda()
{
var input = "$GPZDA,143042.00,25,08,2005,,*6E";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Zda));
var zda = (Zda)msg;
Assert.AreEqual(new DateTime(2005, 08, 25, 14, 30, 42, 00, DateTimeKind.Utc), zda.FixDateTime);
}
public void TestGlzda()
{
var input = "$GLZDA,225627.00,21,09,2015,00,00*70";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Zda));
var zda = (Zda)msg;
Assert.AreEqual(new DateTime(2015, 09, 21, 22, 56, 27, 00, DateTimeKind.Utc), zda.FixDateTime);
}
public void TestGPGGA_NoSats()
{
string input = "$GPGGA,181651.98,3403.47163804,N,11711.80926595,W,0,,,,M,,M,,*6E";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Gga));
Gga gga = (Gga)msg;
Assert.AreEqual(0, gga.NumberOfSatellites);
}
public void TestGnzda()
{
var input = "$GNZDA,075451.00,02,10,2018,00,00*72";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Zda));
var zda = (Zda)msg;
Assert.AreEqual(new DateTime(2018, 10, 02, 07, 54, 51, 00, DateTimeKind.Utc), zda.FixDateTime);
}
/// <summary>
/// Called when the message is being loaded.
/// </summary>
/// <param name="message">The NMEA message values.</param>
protected override void OnLoadMessage(string[] message)
{
if (message == null || message.Length < 7)
{
throw new ArgumentException("Invalid Gpvtg", "message");
}
TrueCourseOverGround = NmeaMessage.StringToDouble(message[0]);
MagneticCourseOverGround = NmeaMessage.StringToDouble(message[2]);
SpeedInKnots = NmeaMessage.StringToDouble(message[4]);
SpeedInKph = NmeaMessage.StringToDouble(message[6]);
}
public static object Parse(NmeaMessage message)
{
GSA gsa = new GSA();
gsa.OperationMode = message.Payload[0] == "A" ? OperationMode.Automatic : OperationMode.Manual;
gsa.FixMode = (FixMode)int.Parse(message.Payload[1]);
gsa.Satellites = message.Payload.Skip(2).Take(12).Where(s => !string.IsNullOrWhiteSpace(s)).Select(int.Parse).ToArray();
gsa.PDOP = GpsUtils.ParseFloat(message.Payload[14]);
gsa.HDOP = GpsUtils.ParseFloat(message.Payload[15]);
gsa.VDOP = GpsUtils.ParseFloat(message.Payload[16]);
return gsa;
}
public void TestPgrmz()
{
string input = "$PGRMZ,93,f,3*21";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(NmeaParser.Nmea.Gps.Garmin.Pgrmz));
var rmz = (NmeaParser.Nmea.Gps.Garmin.Pgrmz)msg;
Assert.AreEqual(93d, rmz.Altitude, "Altitude");
Assert.AreEqual(NmeaParser.Nmea.Gps.Garmin.Pgrmz.AltitudeUnit.Feet, rmz.Unit, "Unit");
Assert.AreEqual(NmeaParser.Nmea.Gps.Garmin.Pgrmz.PositionFixType.Fix3D, rmz.FixType, "FixDimension");
}
public void TestPgrmz_Empty()
{
string input = "$PGRMZ,,,*7E";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(NmeaParser.Nmea.Gps.Garmin.Pgrmz));
var rmz = (NmeaParser.Nmea.Gps.Garmin.Pgrmz)msg;
Assert.AreEqual(double.NaN, rmz.Altitude, "Altitude");
Assert.AreEqual(NmeaParser.Nmea.Gps.Garmin.Pgrmz.AltitudeUnit.Unknown, rmz.Unit, "Unit");
Assert.AreEqual(NmeaParser.Nmea.Gps.Garmin.Pgrmz.PositionFixType.Unknown, rmz.FixType, "FixDimension");
}
public void TestGprmc()
{
string input = "$GPRMC,123519,A,4807.038,S,01131.000,W,022.4,084.4,230313,003.1,W*6A";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Rmc));
Rmc rmc = (Rmc)msg;
Assert.AreEqual(new DateTime(2013, 03, 23, 12, 35, 19, DateTimeKind.Utc), rmc.FixTime);
Assert.AreEqual(-48.1173, rmc.Latitude);
Assert.AreEqual(-11.516666666666667, rmc.Longitude, 0.0000000001);
}
public void Parse_NonMultipartNmea()
{
NmeaMessage msg = NmeaParser.Parse("!AIVDM,1,1,,A,14eG;o@034o8sd<L9i:a;WF>062D,0*7D");
Assert.AreEqual("!AIVDM", msg.MessageType);
Assert.AreEqual(1, msg.NumberOfSentences);
Assert.AreEqual(1, msg.SentenceNumber);
Assert.AreEqual(null, msg.SequentialMessageId);
Assert.AreEqual("A", msg.Channel);
Assert.AreEqual("14eG;o@034o8sd<L9i:a;WF>062D", msg.EncodedPayload);
Assert.AreEqual("0*7D", msg.Checksum);
}
public static object Parse(NmeaMessage message)
{
RMC rmc = new RMC();
rmc.Timestamp = DateTime.ParseExact($"{message.Payload[8]} {message.Payload[0]}", "ddMMyy HHmmss\\.ff", CultureInfo.InvariantCulture);
rmc.NavRecOk = message.Payload[1] == "A";
rmc.Latitude = GpsUtils.DecodeCoordinate(message.Payload[2], message.Payload[3]);
rmc.Longitude = GpsUtils.DecodeCoordinate(message.Payload[4], message.Payload[5]);
rmc.Speed = GpsUtils.ParseFloat(message.Payload[6]);
rmc.Course = GpsUtils.ParseFloat(message.Payload[7]);
rmc.MagneticVariation = GpsUtils.ParseFloat(message.Payload[9]) * (message.Payload[10] == "E" ? 1 : -1);
return rmc;
}
public void TestGpvtg_Empty()
{
string input = "$GPVTG,,T,,M,0.00,N,0.00,K*4E";
var msg = NmeaMessage.Parse(input);
Assert.IsInstanceOfType(msg, typeof(Vtg));
Vtg vtg = (Vtg)msg;
Assert.IsTrue(double.IsNaN(vtg.TrueCourseOverGround));
Assert.IsTrue(double.IsNaN(vtg.MagneticCourseOverGround));
Assert.AreEqual(0.0, vtg.SpeedInKnots);
Assert.AreEqual(0.0, vtg.SpeedInKph);
}
public static object Parse(NmeaMessage message)
{
GGA gga = new GGA();
gga.Timestamp = TimeSpan.ParseExact(message.Payload[0], "hhmmss\\.ff", CultureInfo.InvariantCulture);
gga.Latitude = GpsUtils.DecodeCoordinate(message.Payload[1], message.Payload[2]);
gga.Longitude = GpsUtils.DecodeCoordinate(message.Payload[3], message.Payload[4]);
gga.Quality = (FixQuality)int.Parse(message.Payload[5]);
gga.NumberOfSatellites = byte.Parse(message.Payload[6]);
gga.HDOP = GpsUtils.ParseFloat(message.Payload[7]);
gga.Altitude = GpsUtils.ParseFloat(message.Payload[8]); // TODO: Check data[9] for unit
gga.GeoidalSeparation = GpsUtils.ParseFloat(message.Payload[10]); // TODO: Check data[11] for unit
gga.DGpsAge = GpsUtils.ParseUshort(message.Payload[12]);
gga.DGpsStationId = GpsUtils.ParseUshort(message.Payload[13]);
return gga;
}
/// <summary>
/// Passes an NmeaMessage to the monitor.
/// </summary>
/// <param name="msg">An NMEA message</param>
public void OnMessage(NmeaMessage msg)
{
if (msg == null)
return;
if (msg is NmeaFixMessage)
{
NmeaFixMessage fixMsg = msg as NmeaFixMessage;
LastFixCoord = fixMsg.Coords;
lastFixTime = DateTime.UtcNow;
}
else if (msg is NmeaRecommendedMinimumMessage)
{
NmeaRecommendedMinimumMessage timeMsg = msg as NmeaRecommendedMinimumMessage;
lastGpsTimeValue = timeMsg.DateTime;
lastGpsTimeTimestamp = DateTime.UtcNow;
}
}
