public bool ReadData()
{
  byte[] bData = new byte[256];
  try
  {
    _port.Read(bData, 0, 256);
    _protocol.ParseBuffer(bData);
    _validData = true;
    return true;
  }
  catch
  {
    _validData = false;
    return false;
  }
}

Finally, we need a method to actually return the latitude and longitude from the stored class. If some part of connection process failed, a fake location (-999, -999) is used instead.

public Location GetLocation()
{
  Location gpsLocation = new Location();
  if (_validData)
  {
    gpsLocation.Longitude = _protocol.GPGGA.Longitude;
    gpsLocation.Latitude = _protocol.GPGGA.Latitude;
    gpsLocation.Altitude = _protocol.GPGGA.Altitude;
    _validData = false;
    return gpsLocation;
  }
  else
  {
    gpsLocation.Longitude = -999;
    gpsLocation.Latitude = -999;
    gpsLocation.Altitude = -999;
    return gpsLocation;
  }
}

This the bare minimum needed for a working solution. Additional enhancements could be added later on but for now just go ahead and compile the program. The resulting DLL can now be used in other programs and we will demonstrate that in a future post.

First, open Visual C# Express Edition and create a new class library project.

A class library will compile to a DLL and can be referenced by other projects later on. This is unlike a standard Windows application that produces an executable (EXE) file.

In the Solution Explorer, rename the Class1.cs to something more appropriate. Open the renamed class and change the namespace also.

At the top of code listing, add this line:

using System.IO.Ports;

Then add into this project the 4 C# code files from the Coding 4 Fun project – GPSStructs.cs, Location.cs, NMEAProtocol.cs, and Satellite.cs. Remember, we modified the NMEAProtocol.cs file in our previous post so be sure to read that first.

Coding

Inside our class, we need to add three member variables:

private NMEAProtocol _protocol;
private SerialPort _port;
private bool _validData;

These variables are initially defined in the constructor:

public myGPS()
{
  _protocol = new NMEAProtocol();
  _port = new SerialPort();
  _validData = false;
}

Next, we need a method to connect to the GPS device based on a set of parameters. For this project, we will assume the necessary information on port name and baud rate are already known and will be passed in when the function is called:

public bool Connect(string portName, int baudRate)
{
  try
  {
    _port.PortName = portName; // "COM1", "COM2", etc.
    _port.Parity = Parity.None;
    _port.BaudRate = baudRate; // 4800, 9600, etc.
    _port.StopBits = StopBits.One;
    _port.DataBits = 8;
    _port.Open();
    return true;
  }
  catch
  {
    return false;
  }
}

Conversely, we will need a function to disconnect from the device:

public void Disconnect()
{
  if (_port.IsOpen) _port.Close();
}

To be continued…

GPS receivers communicate using the NMEA protocol. Another device, such as a computer, receives the data in the form of NMEA sentences. There are several different types of NMEA sentences that allow for information on location (GPGGA), accuracy (GPGSA), satellite reception (GPGSV), etc. to be transmitted.

Here is an example of a NMEA sentence:

$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M, ,*47

The sentence type is indicated first ($GPGGA) so we know that this sentence is communicating the current position of the GPS device. To determine the location, we must look at the following portion of the sentence:

4807.038,N,01131.000,E

The first value (4807.038) represents the latitude(Y) while the N represents north (of the equator). To find the actual latitude, the value must be separated after 2 digits to get 48 degrees and 7.038 minutes. Likewise, the longitude(X) value translates to 11 degrees and 31.000 minutes east.

It is important to note that GPGGA sentences communicate the location in degrees and decimal minutes. If we wanted to convert this to decimal degrees, the minutes value would have to be divided by 60 first since there are 60 minutes in a degree:

Decimal degrees = 48 + (7.038 / 60) = 48 + 0.1173 = 48.1173

Conversely, at first glance one might think to just move the decimal place over 2 positions to get decimal degrees (48.07038) but as we already know, this is incorrect. Any mapping programs using this formula will show your location offset in both latitude and longitude.

Now let’s take a look at the Coding 4 Fun formula. In the NMEAProtocol.cs file, find the method named ProcessGPGGA and see how latitude is calculated:

GPGGA.Latitude = Convert.ToDouble(fields[1])/100;

The variable fields[1] contains the entire latitude value (i.e. 4807.038) from the NMEA sentence. But instead of first converting the minutes portion to decimal degrees, the code just divides everything by 100. This produces an incorrect latitude as I discussed above. The process is also repeated for longitude so the code’s location is different from the location in the GPS.

My adjusted code looks like this:

double degrees = Convert.ToDouble(fields[1].Substring(0, 2));
double minutes = Convert.ToDouble(fields[1].Substring(2, 7));
GPGGA.Latitude = Math.Round(degrees + (minutes / 60.0), 6);

I first separate out degrees and minutes and then correctly combine them to produce decimal degrees. I repeated the process for the longitude calculation.

In reality, the math error only produces a small offset that might not even be noticeable unless you were looking at a finer-scaled map. I only discovered the error after using the original code in a mapping application that contained high-resolution aerial photography.

After opening the GPS program in Visual C# Express Edition, you will note that the Coding for Fun project is actually composed of two solutions named GPS and GPSClient. The GPS solution contains 4 files where all the C# code needed to connect and read from a GPS is stored. The second solution is named GPSClient and is just a GUI for displaying the information being transmitted from the GPS device.

Since we are focused on building a GPS solution that can be added to other mapping programs, we will work on building our client application similar to the GPSClient solution. The difference being our result will be a single Dynamically-Linked Library (DLL) that can easily be added to other programs when only GPS location information is needed.

Before creating this DLL though, we will need to understand how the GPS input process works. Let’s briefly discuss the importance of the 4 files in the GPS solution.

GPSStructs.cs

This contains enumerations, structures, and classes used in this application. Look over this code here to get a sense for what type of information will be received from the GPS device.

Location.cs

A very simple class to store latitude, longitude, and altitude.

Satellite.cs

This file contains two classes for storing data about the location of the GPS satellites.

For more information on GPS satellites, see http://en.wikipedia.org/wiki/GPS.

NMEAProtocol.cs

A more complicated class used to interpret the input streams from a GPS device. This class will parse NMEA data and store it into variables that can be easily accessed by the programmer.

I would strongly encourage anyone interested in using GPS to learn at least the basics of NMEA. NMEA is the standard protocol for exporting data from a GPS. Most GPS devices can export data in this format which is basically ASCII text strings in a comma-delimited format (“sentences”).

To learn about the basics of NMEA, see http://en.wikipedia.org/wiki/NMEA

For a detailed description of NMEA data transmissions, see http://www.gpsinformation.org/dale/nmea.htm

The easiest way to explain how this works is using an example. When GPS devices transmit NMEA sentences, each one needs to be interpreted differently. Our focus is on the GPS’s location so one sentence is the GPGGA type:

$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M, ,*47

(see example from http://www.gpsinformation.org/dale/nmea.htm)

NMEA protocol tells us that the latitude is 48 degrees 7.038 minutes north and longitude is 11 degrees 31.00 minutes east. It should be noted that the accuracy of a GPS location varies based on a number of factors.

Fortunately, we don’t have to worry about any of the NMEA sentence translation! In the NMEAProtocol class, look for the ProcessGPGGA method. This is where all the parsing, translation, and math to generate latitude, longitude, altitude, etc. are performed automatically.

Unfortunately, there is an error in the way the Coding 4 Fun solution calculates the longitude and latitude from a GPGGA sentence. Take a look and see if you can figure out what they are doing wrong. The only reason I noticed it is because I did some testing with a GPS device and it didn’t quite match where I was actually standing on planet Earth.

Next time, I’ll go over the math error in some detail and then we will begin building our own GPS solution.

Recently I came across a tutorial on Microsoft’s Coding for Fun site that showed how to connect and read data from a GPS device. I encourage you to read the article, download the source code, and experiment with their solution. It works great although I did come across a math error in their code that I will discuss in a future post.

In order to test the application, you should connect a GPS device to one of your USB ports. Any GPS-enabled device that can export data in the NMEA format will work. Older GPS devices that use a serial port connection will need a Serial to USB adapter. For example, I have a Garmin eTrex Vista along with a Serial to USB adapter that works fine. Recently though I purchased a Pharos iGPS-500 receiver and that functions even better. Since it is powered through the computer, you can leave it run for hours while testing the application and not waste batteries.

The application should compile error free and display a form with four tabs. First chose which COM port your GPS device is connected to under the Set Up tab. If you are unsure, right-click on My Computer and chose Manage. This brings up the Computer Management menu where you can select the Device Manager and navigate to the Ports item on the right-hand list. Here your GPS device will be represented by whatever connector you are using (note the COM port in the parenthesis).

Press the Connect button and wait several seconds. If everything is working right, your current location should be displayed in the Summary tab. To see the actual NMEA data, look at the Raw NMEA Data tab.

As I mentioned above, I believe there is a math error in their code so the latitude location is slightly off. But for now we just want to make sure the overall setup is functioning properly.

Hopefully this introduction will show you how easy it is to read from a GPS device. In the next post, we will breakdown their code, make some changes, and work on producing a DLL that can used in any project requiring GPS input.

]]> http://spatialhorizons.com/2006/12/18/create-your-own-gps-application-using-c-1/feed/ 0