private static void UsingNetwork()
{
try
{
// using (TcpClient client = new TcpClient("192.168.1.43", 10110))
using (TcpClient client = new TcpClient("127.0.0.1", 10110))
{
Console.WriteLine("Connected!");
var stream = client.GetStream();
bool closed = false;
using (NmeaParser parser = new NmeaParser("Test", stream, stream))
{
parser.OnParserError += (source, msg, error) =>
{
Console.WriteLine($"Error while parsing message '{msg}': {error}");
if (error == NmeaError.PortClosed)
{
closed = true;
}
};
parser.OnNewSequence += ParserOnNewSequence;
parser.StartDecode();
while (!Console.KeyAvailable && !closed)
{
Thread.Sleep(1000);
}
}
}
}
catch (SocketException x)
{
Console.WriteLine($"Error connecting to host: {x}");
}
}
public Gps(string gpsDeviceName, BaudRate baudRate)
{
this.GpsDeviceName = gpsDeviceName;
NmeaParser = new NmeaParser();
this.State = new GpsState();
GpsDevice = new SerialDevice(gpsDeviceName, baudRate);
GpsDevice.DataReceived += (sender, bytes) =>
{
var nmeas = DeserializeMessages(bytes);
nmeas.SetGpsState(ref State);
var position = nmeas?.GetPosition();
if (position == null)
{
return;
}
Position = position;
var args = new GpsUpdateEventArgs(Position, State, GpsDevice);
OnGpsUpdate(this, args);
};
}
public ParserData(TcpClient tcpClient, NmeaParser parser, Thread thread)
{
TcpClient = tcpClient;
Parser = parser;
Thread = thread;
TerminateThread = false;
}
private void device_MessageReceived(object sender, NmeaParser.NmeaMessageReceivedEventArgs args)
{
Dispatcher.BeginInvoke((Action) delegate()
{
messages.Enqueue(args.Message.MessageType + ": " + args.Message.ToString());
if (messages.Count > 100) messages.Dequeue(); //Keep message queue at 100
output.Text = string.Join("\n", messages.ToArray());
output.Select(output.Text.Length - 1, 0); //scroll to bottom
if(args.Message is NmeaParser.Nmea.Gps.Gpgsv)
{
var gpgsv = (NmeaParser.Nmea.Gps.Gpgsv)args.Message;
if(args.IsMultipart && args.MessageParts != null)
satView.GpgsvMessages = args.MessageParts.OfType<NmeaParser.Nmea.Gps.Gpgsv>();
}
if (args.Message is NmeaParser.Nmea.Gps.Gprmc)
gprmcView.Message = args.Message as NmeaParser.Nmea.Gps.Gprmc;
else if (args.Message is NmeaParser.Nmea.Gps.Gpgga)
gpggaView.Message = args.Message as NmeaParser.Nmea.Gps.Gpgga;
else if (args.Message is NmeaParser.Nmea.Gps.Gpgsa)
gpgsaView.Message = args.Message as NmeaParser.Nmea.Gps.Gpgsa;
else if (args.Message is NmeaParser.Nmea.Gps.Gpgll)
gpgllView.Message = args.Message as NmeaParser.Nmea.Gps.Gpgll;
else if (args.Message is NmeaParser.Nmea.Gps.Garmin.Pgrme)
pgrmeView.Message = args.Message as NmeaParser.Nmea.Gps.Garmin.Pgrme;
});
}
private bool parseSentence(NmeaParser parser)
{
// ignore non-GPGGA sentences
if (parser.offset < 5
|| parser.cmd[0] != 'G'
|| parser.cmd[1] != 'P'
|| parser.cmd[2] != 'G'
|| parser.cmd[3] != 'G'
|| parser.cmd[4] != 'A'
|| parser.cmd[5] != ',')
{
return false;
}
status = parser.getInt(5);
fix = (status > 0);
if (!fix)
{
// valid sentence, but no GPS fix
return false;
}
sat = parser.getInt(6);
lat = parser.getInt(1);
lon = parser.getInt(3);
return true;
}
/// <summary>
/// Unloads the current device, and opens the next device
/// </summary>
/// <param name="device"></param>
private void StartDevice(NmeaParser.NmeaDevice device)
{
//Clean up old device
if (currentDevice != null)
{
currentDevice.MessageReceived -= device_MessageReceived;
currentDevice.Dispose();
}
output.Text = "";
messages.Clear();
gprmcView.Message = null;
gpggaView.Message = null;
gpgsaView.Message = null;
gpgllView.Message = null;
pgrmeView.Message = null;
satView.GpgsvMessages = null;
//Start new device
currentDevice = device;
currentDevice.MessageReceived += device_MessageReceived;
var _ = currentDevice.OpenAsync();
if (device is NmeaParser.NmeaFileDevice)
currentDeviceInfo.Text = string.Format("NmeaFileDevice( file={0} )", ((NmeaParser.NmeaFileDevice)device).FileName);
else if (device is NmeaParser.SerialPortDevice)
{
currentDeviceInfo.Text = string.Format("SerialPortDevice( port={0}, baud={1} )",
((NmeaParser.SerialPortDevice)device).Port.PortName,
((NmeaParser.SerialPortDevice)device).Port.BaudRate);
}
}
public void AddMessage(NmeaParser.Nmea.NmeaMessage message)
{
messages.Enqueue(message.MessageType + ": " + message.ToString());
if (messages.Count > 100) messages.Dequeue(); //Keep message queue at 100
output.Text = string.Join("\n", messages.ToArray());
output.Select(output.Text.Length - 1, 0); //scroll to bottom
}
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);
}
private void device_MessageReceived(object sender, NmeaParser.NmeaMessageReceivedEventArgs args)
{
var _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
messages.Enqueue(args.Message.MessageType + ": " + args.Message.ToString());
if (messages.Count > 100) messages.Dequeue(); //Keep message queue at 100
output.Text = string.Join("\n", messages.ToArray());
});
}
private double _minimumSpeed = 0.3;//knots
public GpsSensor(ILogger logger, GpsPlugin plugin, string serialPort, int baud)
{
_numberCulture = System.Globalization.CultureInfo.GetCultureInfo("en-us");
_plugin = plugin;
_logger = logger;
_portName = serialPort;
_parser = new NmeaParser();
_baud = baud;
}
public ParseActivity(FileReader file, AisStore store, NmeaParser parseNmea, Counters counters, Tracking tracking, ILogger <ParseActivity> logger)
{
_logger = logger.VerifyNotNull(nameof(logger));
_fileReader = file.VerifyNotNull(nameof(file));
_parseNmea = parseNmea.VerifyNotNull(nameof(parseNmea));
_store = store.VerifyNotNull(nameof(store));
_counters = counters.VerifyNotNull(nameof(counters));
_tracking = tracking.VerifyNotNull(nameof(tracking));
}
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 void VtgMessageTest2()
{
var parser = new NmeaParser();
var result = parser.Parse(VtgMessage2);
Assert.IsInstanceOfType(result, typeof(GpvtgMessage));
var message = (GpvtgMessage)result;
Assert.AreEqual(141.92f, message.TrackDegrees);
Assert.AreEqual(float.NaN, message.MagneticTrack);
Assert.AreEqual(0.89f, message.GroundSpeetKnots);
Assert.AreEqual(1.64f, message.GroundSpeed);
}
public void VtgMessageTest1()
{
var parser = new NmeaParser();
var result = parser.Parse(VtgMessage1);
Assert.IsInstanceOfType(result, typeof(GpvtgMessage));
var message = (GpvtgMessage)result;
Assert.AreEqual(054.7f, message.TrackDegrees);
Assert.AreEqual(034.4f, message.MagneticTrack);
Assert.AreEqual(005.5f, message.GroundSpeetKnots);
Assert.AreEqual(010.2f, message.GroundSpeed);
}
private void device_MessageReceived(object sender, NmeaParser.NmeaMessageReceivedEventArgs args)
{
Dispatcher.BeginInvoke((Action) delegate()
{
messagesWindow.AddMessage(args.Message);
if(args.Message is NmeaParser.Nmea.Gps.Gpgsv)
{
var gpgsv = (NmeaParser.Nmea.Gps.Gpgsv)args.Message;
if(args.IsMultipart && args.MessageParts != null)
skyViewWindow.GpgsvMessages = args.MessageParts.OfType<NmeaParser.Nmea.Gps.Gpgsv>();
}
});
}
static void Main(string[] args)
{
var parser = new NmeaParser();
var dummy = File.ReadAllText("/home/lubuntu/sample.nmea");
//var dummyBytes = Encoding.UTF8.GetBytes(dummy);
var nm = parser.Parse(dummy);
return;
var portNames = SerialDevice.GetPortNames();
var serial = new SerialDevice("/dev/ttyACM0", BaudRate.B1152000);
serial.DataReceived += (o, eventArgs) =>
{
};
serial.Open();
while (true)
{
Thread.Sleep(200);
}
return;
var client = new UdpClient(5554);
var sender = new UdpClient(5556);
var ip = "192.168.100.55";
var exitBs = Encoding.ASCII.GetBytes("AT*CONFIG=\"general:navdata_demo\",\"TRUE\"\r");
var ack = Encoding.ASCII.GetBytes("AT*CTRL=0\r");
sender.Send(exitBs, exitBs.Length, ip, 5556);
sender.Send(ack, ack.Length, ip, 5556);
client.Send(new byte[] { 1 }, 1, ip, 5554);
var nav = new NavDataRetriever("192.168.100.55", 5554, 2000, client);
nav.SendMessage = i => client.Send(new byte[] { (byte)i }, 1, ip, 5554);
nav.Start();
nav.WaitForFirstMessageToArrive();
var navData = nav.CurrentNavigationData;
while (true)
{
navData = nav.CurrentNavigationData;
}
}
public void GsaMessageTest1()
{
var parser = new NmeaParser();
var result = parser.Parse(GsaMessage1);
Assert.IsInstanceOfType(result, typeof(GpgsaMessage));
var message = (GpgsaMessage)result;
Assert.AreEqual(true, message.GpsStatusAuto);
Assert.AreEqual(3, (int)message.SatelliteFix);
Assert.AreEqual("04,05,,09,12,,,24,,,,,", message.Pnrs);
Assert.AreEqual(2.5f, message.Pdop);
Assert.AreEqual(1.3f, message.Hdop);
Assert.AreEqual(2.1f, message.Vdop);
}
private void LoadDevice(NmeaParser.NmeaDevice device)
{
if (mapView.LocationDisplay.LocationProvider != null)
mapView.LocationDisplay.LocationProvider.LocationChanged -= LocationProvider_LocationChanged;
if (currentNmeaDevice != null)
{
currentNmeaDevice.MessageReceived -= device_MessageReceived;
}
currentNmeaDevice = device;
currentNmeaDevice.MessageReceived += device_MessageReceived;
mapView.LocationDisplay.LocationProvider = new NmeaLocationProvider(currentNmeaDevice);
mapView.LocationDisplay.IsEnabled = true;
mapView.LocationDisplay.LocationProvider.LocationChanged += LocationProvider_LocationChanged;
}
static void Main(string[] args)
{
if (args.Length != 4)
{
Console.WriteLine(@"Please provide an input arguments as follows:
1st - Input file with NMEA data,
2nd - Output JSON file path,
3rd - Time offset in seconds,
4th - Speed multipler constant.");
return;
}
if (!ValidateInputArguments(args))
{
return;
}
StreamReader sr = new StreamReader(inputFile.FullName);
List <NmeaMessage> messages = new List <NmeaMessage>();
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
if (line.Contains("$GPGGA") || line.Contains("$GPRMC"))
{
var parser = new NmeaParser();
messages.Add(parser.Parse(line));
}
if (messages.Count == 2)
{
string message = NmeaSenteceToJson(messages, timeOffset, speedMultiplier);
StreamWriter sw = new StreamWriter(outputFile.FullName);
sw.WriteLine(message);
Console.WriteLine(message);
sw.Close();
messages.Clear();
Thread.Sleep(1000);
}
}
sr.Close();
}
public void RmcMessageTest2()
{
var parser = new NmeaParser();
var result = parser.Parse(RmcMessage2);
Assert.IsInstanceOfType(result, typeof(GprmcMessage));
var message = (GprmcMessage)result;
Assert.AreEqual("153007".ToTimeSpan(), message.FixTime);
Assert.AreEqual(true, message.IsActive);
Assert.AreEqual("5050.10288".ToCoordinates("N", CoordinateType.Latitude), message.Latitude);
Assert.AreEqual("00419.91808".ToCoordinates("E", CoordinateType.Longitude), message.Longitude);
Assert.AreEqual(000.1f, message.Speed);
Assert.AreEqual(078.9f, message.Course);
Assert.AreEqual(DateTime.ParseExact("100217", "ddMMyy", CultureInfo.InvariantCulture), message.UpdateDate);
Assert.AreEqual(float.NaN, message.MagneticVariation);
}
public void RmcMessageTest1()
{
var parser = new NmeaParser();
var result = parser.Parse(RmcMessage1);
Assert.IsInstanceOfType(result, typeof(GprmcMessage));
var message = (GprmcMessage)result;
Assert.AreEqual("091317.75".ToTimeSpan(), message.FixTime);
Assert.AreEqual(true, message.IsActive);
Assert.AreEqual("5037.0967674".ToCoordinates("N", CoordinateType.Latitude), message.Latitude);
Assert.AreEqual("00534.6232070".ToCoordinates("E", CoordinateType.Longitude), message.Longitude);
Assert.AreEqual(0.019f, message.Speed);
Assert.AreEqual(215.1f, message.Course);
Assert.AreEqual(DateTime.ParseExact("220816", "ddMMyy", CultureInfo.InvariantCulture), message.UpdateDate);
Assert.AreEqual(0.0f, message.MagneticVariation);
}
private void Form1_Load(object sender, EventArgs e)
{
_parser = new NmeaParser();
_parser.NmeaSentenceReceived += new NmeaSentenceReceivedEventHandler(_parser_NmeaSentenceReceived);
string[] ports = SerialPortReader.GetAvailablePorts();
if (ports != null && ports.Length > 0)
{
this._comPorts.Items.AddRange(ports);
this._comPorts.SelectedIndex = 0;
}
string port = this._comPorts.SelectedItem as string;
_portReader = new SerialPortReader(port);
_portReader.DataReceived += new GpsDataReceivedEventHandler(_portReader_DataReceived);
UpdateControls();
}
private void Form1_Load(object sender, EventArgs e)
{
_parser = new NmeaParser();
_parser.NmeaSentenceReceived += new NmeaSentenceReceivedEventHandler(_parser_NmeaSentenceReceived);
string[] ports = SerialPortReader.GetAvailablePorts();
if (ports != null && ports.Length > 0)
{
this._comPorts.Items.AddRange(ports);
this._comPorts.SelectedIndex = 0;
}
string port = this._comPorts.SelectedItem as string;
_portReader = new SerialPortReader(port);
_portReader.DataReceived += new GpsDataReceivedEventHandler(_portReader_DataReceived);
UpdateControls();
}
static void Main(string[] args)
{
var parser = new NmeaParser();
Console.WriteLine($"Parsing GPGGA message: {GgaMessage1}");
var result = parser.Parse(GgaMessage1);
Console.WriteLine($"Result: {result}");
Console.WriteLine($"Parsing GPRMC message: {RmcMessage1}");
result = parser.Parse(RmcMessage1);
Console.WriteLine($"Result: {result}");
Console.WriteLine($"Parsing GPRMC message 2: {RmcMessage2}");
result = parser.Parse(RmcMessage2);
Console.WriteLine($"Result: {result}");
Console.WriteLine("Press enter to continue...");
Console.ReadKey();
}
public void GgaMessageTest1()
{
var parser = new NmeaParser();
var result = parser.Parse(GgaMessage1);
Assert.IsInstanceOfType(result, typeof(GpggaMessage));
var message = (GpggaMessage)result;
Assert.AreEqual("091317.80".ToTimeSpan(), message.FixTime);
Assert.AreEqual("5037.0968".ToCoordinates("N", CoordinateType.Latitude), message.Latitude);
Assert.AreEqual("00534.6232".ToCoordinates("E", CoordinateType.Longitude), message.Longitude);
Assert.AreEqual(9, (int)message.FixQuality);
Assert.AreEqual(7, message.NumberOfSatellites);
Assert.AreEqual(1.4f, message.Hdop);
Assert.AreEqual(73.65f, message.Altitude);
Assert.AreEqual("M", message.AltitudeUnits);
Assert.AreEqual(46.60f, message.HeightOfGeoId);
Assert.AreEqual("M", message.HeightOfGeoIdUnits);
Assert.AreEqual(5, message.TimeSpanSinceDgpsUpdate);
Assert.AreEqual(136, message.DgpsStationId);
}
void device_MessageReceived(object sender, NmeaParser.NmeaMessageReceivedEventArgs e)
{
var message = e.Message;
if (message is NmeaParser.Nmea.Gps.Garmin.Pgrme)
{
m_Accuracy = ((NmeaParser.Nmea.Gps.Garmin.Pgrme)message).HorizontalError;
}
else if (message is NmeaParser.Nmea.Gps.Gprmc)
{
var rmc = (NmeaParser.Nmea.Gps.Gprmc)message;
if(rmc.Active && LocationChanged != null)
{
LocationChanged(this, new Esri.ArcGISRuntime.Location.LocationInfo()
{
Course = rmc.Course,
Speed = rmc.Speed,
HorizontalAccuracy = m_Accuracy,
Location = new Esri.ArcGISRuntime.Geometry.MapPoint(rmc.Longitude, rmc.Latitude, SpatialReferences.Wgs84)
});
}
}
}
static void Main(string[] args)
{
_LastSent = DateTime.Now;
var utc = DateTime.UtcNow;
var fileName = $"{utc.Year}-{utc.Month}-{utc.Day}={utc.Hour}-{utc.Minute}-{utc.Second}.log";
_streamWriter = File.AppendText(fileName);
try
{
var connectionString = "HostName=iotc-6e7ea251-71bd-4024-a0a8-a8895ea79b7f.azure-devices.net;DeviceId=GeoTracker1;SharedAccessKey=a99ZyFyYPR0tQl7vWK75y4C3YveuQmK118LYEgsYC5c=";
_deviceClient = DeviceClient.CreateFromConnectionString(connectionString);
}
catch (Exception ex)
{
Console.WriteLine($"Exception during IoT connection {ex}");
}
Console.WriteLine("Read serial port");
_parser = new NmeaParser();
_parser.NmeaMessageParsed += NmeaMessageParsed;
_SerialReader = new SerialReader();
_SerialReader.NmeaSentenceReceived += NmeaSentenceReceived;
_SerialReader.Open();
Console.WriteLine("Initialized...");
Console.ReadKey();
}
private void Connect(IAsyncResult result)
{
if (result.IsCompleted)
{
var data = bluetoothClient.GetStream();
while (true)
{
if (data.CanRead)
{
GpggaMessage parsedMessage = new GpggaMessage();
var message = new byte[256];
var completeMessage = new StringBuilder();
do
{
var numberOfBytesRead = data.Read(message, 0, message.Length);
completeMessage.AppendFormat("{0}", Encoding.ASCII.GetString(message, 0, numberOfBytesRead));
}while (data.DataAvailable);
try
{
var nmeaParser = new NmeaParser();
var messages = completeMessage.ToString();
parsedMessage = (GpggaMessage)nmeaParser.Parse(completeMessage.ToString());
if (parsedMessage != null)
{
ParseCoordinates(completeMessage, parsedMessage);
}
}
catch
{
;
}
}
}
}
}
public override SensorFile ImportFile(string path, Boat boat)
{
int line = 0;
StringBuilder log = new StringBuilder();
try
{
FileInfo fi = new FileInfo(path);
SensorFile file = new SensorFile("nmea", fi.Name, DateTime.Now);
file.Save();
StreamReader reader = new StreamReader(path);
Dictionary <string, Dictionary <string, string> > first = null;
if (!reader.EndOfStream)
{
while (first == null && !reader.EndOfStream)
{
try
{
string lineText = reader.ReadLine();
first = NmeaParser.Parse(lineText);
}
catch (NMEAIgnoredSentenceException) { }
catch (NMEAUnkownSentenceException) { }
catch (NMEAEmptySentenceException) { }
catch (Exception e)
{
log.Append("Line " + line + ": " + e.Message);
log.Append(Environment.NewLine);
}
line++;
}
while (!reader.EndOfStream)
{
try
{
Dictionary <string, Dictionary <string, string> > current = first;
bool newGroup = true;
double latitude = 0;
double longitude = 0;
double speed = 0;
double waterTemperature = 0;
double depth = 0;
double relativeWindSpeed = 0;
double relativeWindAngle = 0;
double heading = 0;
TimeSpan? time = null;
Exception groupException = null;
while (newGroup || (current.Keys.ElementAt(0) != first.Keys.ElementAt(0) && !reader.EndOfStream))
{
try
{
//process current
if (current.Keys.ElementAt(0) == "Global Positioning System Fix Data")
{
//time
string timestring = current[current.Keys.ElementAt(0)]["Time"];
char[] splitter = { '.' };
string[] parts = timestring.Split(splitter);
if (parts[0].Length == 6)
{
int hour = int.Parse(parts[0].Substring(0, 2));
int minute = int.Parse(parts[0].Substring(2, 2));
int second = int.Parse(parts[0].Substring(4, 2));
int millisecond = 0;
if (parts.Length > 1)
{
millisecond =
(int)
(double.Parse("0." + parts[1], _numberCulture.NumberFormat) *
1000.0);
}
time = new TimeSpan(0, hour, minute, second, millisecond);
}
else
{
throw new Exception("Invalid Time Format");
}
//latitude
string latitudeString = current[current.Keys.ElementAt(0)]["Latitude"];
string latitudeDirectionString =
current[current.Keys.ElementAt(0)]["Latitude Direction"];
if (latitudeString.Length > 2)
{
int latdegrees = int.Parse(latitudeString.Substring(0, 2));
double latminute = double.Parse(latitudeString.Substring(2),
_numberCulture.NumberFormat);
latitude = Coordinate.CoordinateToDouble(latdegrees, latminute, 0);
if (latitudeDirectionString.ToLower() == "s")
{
latitude = -latitude;
}
}
else
{
throw new Exception("Invalid Latitude format");
}
//longitude
string longitudeString = current[current.Keys.ElementAt(0)]["Longitude"];
string longitudeDirectionString =
current[current.Keys.ElementAt(0)]["Longitude Direction"];
if (longitudeString.Length > 2)
{
int longdegrees = int.Parse(longitudeString.Substring(0, 3));
double longminute = double.Parse(longitudeString.Substring(3),
_numberCulture.NumberFormat);
longitude = Coordinate.CoordinateToDouble(longdegrees, longminute, 0);
if (longitudeDirectionString.ToLower() == "w")
{
longitude = -longitude;
}
}
else
{
throw new Exception("Invalid Longitude format");
}
}
else if (current.Keys.ElementAt(0) == "Recommended Minimum Specific GPS/TRANSIT Data")
{
//time
string timestring = current[current.Keys.ElementAt(0)]["Time of Fix"];
char[] splitter = { '.' };
string[] parts = timestring.Split(splitter);
if (parts[0].Length == 6)
{
int hour = int.Parse(parts[0].Substring(0, 2));
int minute = int.Parse(parts[0].Substring(2, 2));
int second = int.Parse(parts[0].Substring(4, 2));
time = new TimeSpan(0, hour, minute, second, 0);
}
else
{
throw new Exception("Invalid Time Format");
}
//latitude
string latitudeString = current[current.Keys.ElementAt(0)]["Latitude"];
string latitudeDirectionString =
current[current.Keys.ElementAt(0)]["Latitude Direction"];
if (latitudeString.Length > 2)
{
int latdegrees = int.Parse(latitudeString.Substring(0, 2));
double latminute = double.Parse(latitudeString.Substring(2),
_numberCulture.NumberFormat);
latitude = Coordinate.CoordinateToDouble(latdegrees, latminute, 0);
if (latitudeDirectionString.ToLower() == "s")
{
latitude = -latitude;
}
}
else
{
throw new Exception("Invalid Latitude format");
}
//longitude
string longitudeString = current[current.Keys.ElementAt(0)]["Longitude"];
string longitudeDirectionString =
current[current.Keys.ElementAt(0)]["Longitude Direction"];
if (longitudeString.Length > 2)
{
int longdegrees = int.Parse(longitudeString.Substring(0, 3));
double longminute = double.Parse(longitudeString.Substring(3),
_numberCulture.NumberFormat);
longitude = Coordinate.CoordinateToDouble(longdegrees, longminute, 0);
if (longitudeDirectionString.ToLower() == "w")
{
longitude = -longitude;
}
}
else
{
throw new Exception("Invalid Longitude format");
}
string speedString = current[current.Keys.ElementAt(0)]["Speed over ground"];
double.TryParse(speedString, out speed);
//speed = double.Parse(speedString, _numberCulture.NumberFormat);
string datestring = current[current.Keys.ElementAt(0)]["Date of Fix"];
if (datestring.Length == 6)
{
int day = int.Parse(datestring.Substring(0, 2));
int month = int.Parse(datestring.Substring(2, 2));
int year = 2000 + int.Parse(datestring.Substring(4, 2));
DateTime dt = new DateTime(year, month, day);
dt = ZeroTime(dt);
StartDate = dt;
time = new TimeSpan(0, time.Value.Hours, time.Value.Minutes,
time.Value.Seconds, time.Value.Milliseconds);
}
else
{
throw new Exception("Invalid Time Format");
}
}
else if (current.Keys.ElementAt(0) == "Data and Time")
{
//time
string timestring = current[current.Keys.ElementAt(0)]["Time"];
char[] splitter = { '.' };
string[] parts = timestring.Split(splitter);
if (parts[0].Length == 6)
{
int hour = int.Parse(parts[0].Substring(0, 2));
int minute = int.Parse(parts[0].Substring(2, 2));
int second = int.Parse(parts[0].Substring(4, 2));
int millisecond =
(int)
(double.Parse("0." + parts[1], _numberCulture.NumberFormat) *
1000.0);
int day = int.Parse(current[current.Keys.ElementAt(0)]["Day"]);
int month = int.Parse(current[current.Keys.ElementAt(0)]["Month"]);
int year = int.Parse(current[current.Keys.ElementAt(0)]["Year"]);
DateTime dt = new DateTime(year, month, day);
dt = ZeroTime(dt);
StartDate = dt;
time = new TimeSpan(0, hour, minute, second, millisecond);
}
else
{
throw new Exception("Invalid Time Format");
}
}
else if (current.Keys.ElementAt(0) == "Water Temperature")
{
string tempString = current[current.Keys.ElementAt(0)]["Water Temperature"];
string tempUnitString =
current[current.Keys.ElementAt(0)]["Water Temperature Unit"];
waterTemperature = double.Parse(tempString, _numberCulture.NumberFormat);
//convert fahrenheit to celsius
if (tempUnitString.ToLower() == "f")
{
waterTemperature = (5.0 / 9.0) * (waterTemperature - 32.0);
}
}
else if (current.Keys.ElementAt(0) == "Depth")
{
string depthString = current[current.Keys.ElementAt(0)]["Depth"];
depth = double.Parse(depthString, _numberCulture.NumberFormat);
}
else if (current.Keys.ElementAt(0) == "Wind Speed and Angle")
{
string windAngleString = current[current.Keys.ElementAt(0)]["Wind Angle"];
string windspeedString = current[current.Keys.ElementAt(0)]["Wind Speed"];
string windspeedUnitString =
current[current.Keys.ElementAt(0)]["Wind Speed Unit"];
relativeWindAngle = double.Parse(windAngleString,
_numberCulture.NumberFormat);
relativeWindSpeed =
ConvertValueWithUnit(windspeedString + " " + windspeedUnitString);
}
else if (current.Keys.ElementAt(0) == "NovaSail")
{
string latitudeString = current[current.Keys.ElementAt(0)]["Latitude"];
string longitudeString = current[current.Keys.ElementAt(0)]["Longitude"];
string headingString = current[current.Keys.ElementAt(0)]["Heading"];
string speedString = current[current.Keys.ElementAt(0)]["Speed"];
string rollString = current[current.Keys.ElementAt(0)]["Roll"];
string dayString = current[current.Keys.ElementAt(0)]["Day"];
string monthString = current[current.Keys.ElementAt(0)]["Month"];
string yearString = current[current.Keys.ElementAt(0)]["Year"];
string hourString = current[current.Keys.ElementAt(0)]["Hour"];
string minuteString = current[current.Keys.ElementAt(0)]["Minute"];
string secondString = current[current.Keys.ElementAt(0)]["Second"];
latitude = double.Parse(latitudeString, _numberCulture.NumberFormat);
longitude = double.Parse(longitudeString, _numberCulture.NumberFormat);
speed = double.Parse(speedString, _numberCulture.NumberFormat);
heading = double.Parse(headingString, _numberCulture.NumberFormat);
//roll
DateTime dt = new DateTime(int.Parse(yearString), int.Parse(monthString),
int.Parse(dayString));
dt = ZeroTime(dt);
StartDate = dt;
time = new TimeSpan(0, int.Parse(hourString), int.Parse(minuteString),
int.Parse(secondString), 0);
}
}
catch (Exception ex)
{
groupException = ex;
}
line++;
string lineText = reader.ReadLine();
current = NmeaParser.Parse(lineText);
newGroup = false;
}
if (time != null && groupException == null)
{
file.AddReading(StartDate + time.Value, latitude, longitude, 0, speed, heading, depth, waterTemperature, 0, relativeWindAngle, relativeWindSpeed, 0, 0);
}
else
{
//log something?
log.Append("The date and time could not be determined at line " + line);
log.Append(Environment.NewLine);
}
first = current;
}
catch (NMEAIgnoredSentenceException) {}
catch (NMEAUnkownSentenceException) {}
catch (NMEAEmptySentenceException) {}
catch (Exception e)
{
log.Append("Line " + line + ": " + e.Message);
log.Append(Environment.NewLine);
}
}
boat.AddFile(file);
if (log.Length > 0)
{
if (log.ToString().Length > 1000)
{
MessageBox.Show(log.ToString().Substring(0, 1000));
}
else
{
MessageBox.Show(log.ToString());
}
}
return(file);
}
else
{
return(null);
}
}
catch (Exception)
{
return(null);
}
}
public NmeaMessage GetNmeaMessage(string nmea)
{
return(NmeaParser.Parse(nmea));
}
public NmeaLocationProvider(NmeaParser.NmeaDevice device)
{
this.device = device;
device.MessageReceived += device_MessageReceived;
}
public override bool Connect()
{
var data = (FileGpsInfo)GpsInfo;
IsRunning = true;
OnGpsStatusChanged(GpsStatus.Connecting);
var parser = new NmeaParser();
var gpsdDataParser = new GpsdDataParser();
var headerLine = true;
var latColumnIndex = 0;
var longColumnIndex = 0;
var minArraySize = 0;
try
{
using (var streamReader = File.OpenText(data.FilePath))
{
string line;
OnGpsStatusChanged(GpsStatus.Connected);
while (IsRunning && (line = streamReader.ReadLine()) != null)
{
OnRawGpsDataReceived(line);
switch (data.FileType)
{
case FileType.Nmea:
var nmeaResult = parser.Parse(line);
var result = nmeaResult as GprmcMessage;
if (result == null)
{
continue;
}
OnGpsDataReceived(new GpsDataEventArgs(result));
break;
case FileType.Gpsd:
var gpsdResult = gpsdDataParser.GetGpsData(line);
var gpsLocation = gpsdResult as GpsLocation;
if (gpsLocation == null)
{
continue;
}
OnGpsDataReceived(new GpsDataEventArgs(gpsLocation));
break;
case FileType.LatitudeLongitude:
if (headerLine)
{
var headers = line.Split(';');
for (var i = 0; i < headers.Length; i++)
{
if (headers[i] == Properties.Settings.Default.File_Latitude_Header)
{
latColumnIndex = i;
}
if (headers[i] == Properties.Settings.Default.File_Longitude_Header)
{
longColumnIndex = i;
}
}
minArraySize = Math.Max(latColumnIndex, longColumnIndex);
headerLine = false;
}
else
{
var latLongResult = line.Split(';');
if (latLongResult.Length < 2)
{
throw new InvalidFileFormatException(data.FilePath);
}
if (latLongResult.Length < minArraySize)
{
continue;
}
double latitude;
if (
!double.TryParse(latLongResult[latColumnIndex], NumberStyles.Any,
CultureInfo.InvariantCulture, out latitude))
{
continue;
}
double longitude;
if (
!double.TryParse(latLongResult[longColumnIndex], NumberStyles.Any,
CultureInfo.InvariantCulture, out longitude))
{
continue;
}
var message = new GpsDataEventArgs(latitude, longitude);
OnGpsDataReceived(message);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
Thread.Sleep(data.ReadFrequenty);
}
Disconnect();
return(true);
}
}
catch
{
Disconnect();
throw;
}
}
public static NmeaMessage ParseNmea(string nmea)
{
return(NmeaParser.Parse(nmea));
}
