Learn how to use MediaTek 3329-based GPS shields with Arduino in Chapter 19 of our Arduino Tutorials. The first chapter is here, the complete series is detailed here. If you have an EM406A GPS module, please visit the separate tutorial. Updated 15/01/2014
Introduction
In this instalment we will introduce and examine the use of the Global Positioning System receivers with Arduino systems. What is the GPS? In very simple terms, a fleet of satellites orbit the earth, transmitting signals from space. Your GPS receiver uses signals from these satellites to triangulate position, altitude, compass headings, etc.; and also receives a time and date signal from these satellites.
The most popular GPS belongs to the USA, and was originally for military use – however it is now available for users in the free world.
Interestingly, the US can switch off or reduce accuracy of their GPS in various regions if necessary, however many people tell me this is not an issue unless you’re in a combat zone against the US forces. For more information, have a look at Wikipedia or the USAF Space Command GPS Ops Centre site. As expected, other countries have their own GPS as well – such as Russia, China, and the EU is working on one as well.
So – how can us mere mortals take advantage of a multi-billion dollar space navigation system just with our simple Arduino? Easy – with an inexpensive GPS receiver and shield. In this tutorial we’ll use a GPS shield based on the MediaTek3329 GPS receiver from Tronixlabs.
Unlike the EM406A used in the other tutorial, the whole lot is all on one shield – and after some experimenting has better reception. Plus there’s an onboard SD card socket which we’ll use for a GPS logging device. The only catch is that you need to solder the stacking headers yourself. (update – if purchased from Tronixlabs these will be fully assembled):
Apart from the GPS shield we’ll also be using a typical Arduino-compatible LCD shield and of course an Arduino Uno or compatible. Finally before getting started, you need to set the two jumpers on the GPS shield as shown in the following image:
By doing this the serial data lines from the GPS receiver can be connected to Arduino D2 and D3 – which we will use with SoftwareSerial. The benefit of doing it this way is that you can then upload sketches without any hardware changes and also use the serial monitor and GPS at the same time. So let’s get started.
Testing your GPS shield
Simply connect your GPS shield as described above to your Arduino Uno or compatible, and upload the following sketch:
// Example 19.1
#include <SoftwareSerial.h>
SoftwareSerial GPS(2,3); // configure software serial port -
void setup()
{
GPS.begin(9600);
Serial.begin(9600);
}
void loop()
{
byte a;
if (GPS.available() > 0 )
{
a = GPS.read(); // get the byte of data from the GPS
Serial.write(a);
}
}Note the use of SoftwareSerial in the sketch. As mentioned earlier, the GPS data is transferred to the Arduino via D2/D2 – which we set up as a software serial port.
If possible try to get your hardware close to a window, then open the serial monitor window. The first time you power up your receiver, it may take a minute or so to lock onto the available satellites, this period of time is the cold start time.
The subsequent times you power it up, the searching time is reduced somewhat as our receiver stores some energy in a supercap (very high-value capacitor) to remember the satellite data, which it will use the next time to reduce the search time (as it already has a “fair idea” where the satellites are).
Moving on, after a few moments you should be presented with a scrolling wall of text, for example:
What on Earth does all that mean? For one thing the hardware is working correctly. Excellent! Now how do we decode these space-signals… They are called NMEA codes. Let’s break down one and see what it means. For example, the line:
$GPRMC,100748.000,A,3754.9976,S,14507.0283,E,0.00,263.36,140114,,,A*70
- $GPRMC tells us the following data is essential point-velocity-time data;
- 100748.000 is the universal time constant (Greenwich Mean Time) – 10:07:48 (hours, minutes, seconds). So you now have a clock as well.
- A is status – A for active and data is valid, V for void and data is not valid.
- 3754.9976 is degrees latitude position data = 37 degrees, 54.9976′
- S for south (south is negative, north is positive)
- 14507.0283 is degrees longitude position data = 145 degrees, 07.0283′
- E for east (east is positive, west is negative)
- 0.00 is my speed in knots over ground. This shows the inaccuracy that can be caused by not having a clear view of the sky
- 263.36 – course over ground (0 is north, 180 is south, 270 is west, 90 is east)
- 140114 is the date – 14th January 2014
- the next is magnetic variation for which we don’t have a value
- checksum number
Thankfully the data is separated by commas. This will be useful later when you log the data to a text file using the SD card, as you will then be able to use the data in a spreadsheet very easily. For more explanation about the data, here is the NMEA Reference Manual that explains them all.
Extracting the GPS data
You can’t decode all that NMEA on the fly, so thankfully there is an Arduino library to do this for us – TinyGPS. So head over to the library website, download and install the library before continuing.
Now with the same hardware from the previous example, upload the following sketch:
// Example 19.2
#include <TinyGPS.h>
#include <SoftwareSerial.h>
SoftwareSerial GPS(2,3); // configure software serial port
// Create an instance of the TinyGPS object
TinyGPS shield;
void setup()
{
GPS.begin(9600);
Serial.begin(9600);
}
// The getgps function will interpret data from GPS and display on serial monitor
void getgps(TinyGPS &gps)
{
// Define the variables that will be used
float latitude, longitude;
// Then call this function
shield.f_get_position(&latitude, &longitude);
Serial.println("--------------------------------------------------------------");
Serial.print("Lat: ");
Serial.print(latitude,5);
Serial.print(" Long: ");
Serial.println(longitude,5);
int year;
byte month, day, hour, minute, second, hundredths;
shield.crack_datetime(&year,&month,&day,&hour,&minute,&second,&hundredths);
// Print data and time
Serial.print("GMT - ");
Serial.print(hour, DEC);
Serial.print(":");
if (minute<10)
{
Serial.print("0");
Serial.print(minute, DEC);
}
else if (minute>=10)
{
Serial.print(minute, DEC);
}
Serial.print(":");
if (second<10)
{
Serial.print("0");
Serial.print(second, DEC);
}
else if (second>=10)
{
Serial.print(second, DEC);
}
Serial.print(" ");
Serial.print(day, DEC);
Serial.print("/");
Serial.print(month, DEC);
Serial.print("/");
Serial.println(year, DEC);
Serial.print("Altitude ");
Serial.print(gps.f_altitude());
Serial.print("m ");
Serial.print(gps.f_speed_kmph());
Serial.println("km/h");
}
void loop()
{
byte a;
if ( GPS.available() > 0 ) // if there is data coming from the GPS shield
{
a = GPS.read(); // get the byte of data
if(shield.encode(a)) // if there is valid GPS data...
{
getgps(shield); // then grab the data and display it on the LCD
}
}
}How this works is quite simple. In void loop() the sketch waits for data to come from the GPS receiver, and then checks if it’s valid GPS data. Then it passes over to the function getgps() which uses the function:
shield.f_get_position
to extract the location data and place it in two variables. Next, another function:
shield.crack_datetime
will extract the date and time data, and place them in the pre-determined variables. Finally the use of
gps.f_altitude
and
gps.f_speed_kmph
can be assigned to variables as they store the altitude and speed respectively. These functions will be commonly used across all the examples, so you can see how they can be used.
To test the sketch, position the hardware and open the serial monitor. After a moment you should be presented with the GPS data in a much more useful form, for example:
At this point you should be able to form ideas of how to harness that data and display or work with it in a more useful way. Useful hint – you can enter coordinates directly into Google Maps to see where it is, for example:
A portable GPS display
Now that you can extract the GPS data, it’s a simple matter of sending it to an LCD shield for display. Just add the LCD shield to your hardware and upload the next sketch. Be sure to change the values in the LiquidCrysal LCD… line if your shield uses different digital pins.
// Example 19.3
#include <TinyGPS.h>
#include <SoftwareSerial.h>
SoftwareSerial GPS(2,3); // configure software serial port
// Create an instance of the TinyGPS object
TinyGPS shield;
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);
void setup()
{
lcd.begin(16, 2);
lcd.clear();
lcd.print("tronixstuff.com");
GPS.begin(9600);
delay(1000);
lcd.clear();
}
// The getgps function will interpret data from GPS and display on serial monitor
void getgps(TinyGPS &gps)
{
// Define the variables that will be used
float latitude, longitude;
// Then call this function
shield.f_get_position(&latitude, &longitude);
lcd.setCursor(0,0);
lcd.print("Lat: ");
lcd.print(latitude,5);
lcd.print(" ");
lcd.setCursor(0,1);
lcd.print("Long: ");
lcd.print(longitude,5);
lcd.print(" ");
}
void loop()
{
byte a;
if ( GPS.available() > 0 ) // if there is data coming from the GPS shield
{
a = GPS.read(); // get the byte of data
if(shield.encode(a)) // if there is valid GPS data...
{
getgps(shield); // then grab the data and display it on the LCD
}
}
}Again, position the hardware and your current position should be shown on the LCD, for example:
A GPS Clock
Armed with the same hardware you can also create a GPS clock. With this you can finally have a reference clock and end all arguments about the correct time without calling the speaking clock. Just use the same hardware from the previous example and upload the following sketch:
// Example 19.4
#include <TinyGPS.h>
#include <SoftwareSerial.h>
SoftwareSerial GPS(2,3); // configure software serial port
// Create an instance of the TinyGPS object
TinyGPS shield;
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);
void setup()
{
lcd.begin(16, 2);
lcd.clear();
lcd.print("tronixstuff.com");
GPS.begin(9600);
delay(1000);
lcd.clear();
}
// The getgps function will interpret data from GPS and display on serial monitor
void getgps(TinyGPS &gps)
{
int year;
byte month, day, hour, minute, second, hundredths;
shield.crack_datetime(&year,&month,&day,&hour,&minute,&second,&hundredths);
// Print data and time
lcd.setCursor(0,0);
lcd.print("GMT - ");
lcd.print(hour, DEC);
lcd.print(":");
if (minute<10)
{
lcd.print("0");
lcd.print(minute, DEC);
}
else if (minute>=10)
{
lcd.print(minute, DEC);
}
lcd.print(":");
if (second<10)
{
lcd.print("0");
lcd.print(second, DEC);
}
else if (second>=10)
{
lcd.print(second, DEC);
}
lcd.setCursor(0,1);
lcd.print(day, DEC);
lcd.print("/");
lcd.print(month, DEC);
lcd.print("/");
lcd.print(year, DEC);
}
void loop()
{
byte a;
if ( GPS.available() > 0 ) // if there is data coming from the GPS shield
{
a = GPS.read(); // get the byte of data
if(shield.encode(a)) // if there is valid GPS data...
{
getgps(shield); // then grab the data and display it on the LCD
}
}
}Now position the hardware again, and after a moment the time will appear – as shown in this video.
Unless you live in the UK or really need to know what GMT/UTC is, a little extra work is required to display your local time. First you will need to know in which time zone you are located – find it in this map.
If your time zone is positive (e.g. GMT +10) – you need to add 10 to your hour value, and if it’s over 23 you then subtract 24 to get the correct hours.
If your time zone is negative (e.g. GMT – 5) – you need to subtract 5 from your hour value, and if it’s under zero you then add 24 to get the correct hours.
GPS Speedometer
Just as with the clock, it’s easy to display the speed readings with the LCD. Using the same hardware as above, enter and upload the following sketch:
// Example 19.5
#include <TinyGPS.h>
#include <SoftwareSerial.h>
SoftwareSerial GPS(2,3); // configure software serial port
// Create an instance of the TinyGPS object
TinyGPS shield;
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);
void setup()
{
lcd.begin(16, 2);
lcd.clear();
lcd.print("tronixstuff.com");
GPS.begin(9600);
delay(1000);
lcd.clear();
}
// The getgps function will interpret data from GPS and display on serial monitor
void getgps(TinyGPS &gps)
{
int year;
byte month, day, hour, minute, second, hundredths, kmh, mph;
shield.crack_datetime(&year,&month,&day,&hour,&minute,&second,&hundredths);
// Print data and time
lcd.setCursor(0,0);
kmh=gps.f_speed_kmph();
lcd.print(kmh, DEC);
lcd.print(" km/h ");
/*
mph = kmh * 1.6;
lcd.print(mph, DEC);
lcd.print(" MPH ");
*/
}
void loop()
{
byte a;
if ( GPS.available() > 0 ) // if there is data coming from the GPS shield
{
a = GPS.read(); // get the byte of data
if(shield.encode(a)) // if there is valid GPS data...
{
getgps(shield); // then grab the data and display it on the LCD
}
}
}Now position the hardware again, and after a moment your speed should appear. You might get some odd readings if indoors, as the receiver needs data from several satellites to accurately determine your speed. The sketch is written for km/h, however you can replace the display lines with the section that is commented out to display miles per hour.
So at this point find a car and driver, an external power supply and go for a drive. You may find the GPS speed is quite different to the vehicle’s speedometer.
Build a GPS logging device
And for our final example, let’s make a device that captures the position, speed and time data to SD card for later analysis. The required hardware is just the GPS shield and Arduino Uno or compatible board – plus an SD memory card that is formatted to FAT16. SDXC cards may or may not work, they’re quite finicky – so try and get an older standard card.
Now enter and upload the following sketch:
// Example 19.6
#include <SD.h>
#include <TinyGPS.h>
#include <SoftwareSerial.h>
SoftwareSerial shield(2,3); // configure software serial port
// Create an instance of the TinyGPS object
TinyGPS gps;
void setup()
{
pinMode(10, OUTPUT);
shield.begin(9600);
Serial.begin(9600);
// check that the microSD card exists and can be used v
if (!SD.begin(10)) {
Serial.println("Card failed, or not present");
// stop the sketch
return;
}
Serial.println("SD card is ready");
}
void getgps(TinyGPS &gps)
{
float latitude, longitude;
int year;
byte month, day, hour, minute, second, hundredths;
//decode and display position data
gps.f_get_position(&latitude, &longitude);
File dataFile = SD.open("DATA.TXT", FILE_WRITE);
// if the file is ready, write to it
if (dataFile)
{
dataFile.print("Lat: ");
dataFile.print(latitude,5);
dataFile.print(" ");
dataFile.print("Long: ");
dataFile.print(longitude,5);
dataFile.print(" ");
// decode and display time data
gps.crack_datetime(&year,&month,&day,&hour,&minute,&second,&hundredths);
// correct for your time zone as in Project #45
hour=hour+11;
if (hour>23)
{
hour=hour-24;
}
if (hour<10)
{
dataFile.print("0");
}
dataFile.print(hour, DEC);
dataFile.print(":");
if (minute<10)
{
dataFile.print("0");
}
dataFile.print(minute, DEC);
dataFile.print(":");
if (second<10)
{
dataFile.print("0");
}
dataFile.print(second, DEC);
dataFile.print(" ");
dataFile.print(gps.f_speed_kmph());
dataFile.println("km/h");
dataFile.close(); // this is mandatory
delay(10000); // record a measurement about every 10 seconds
}
}
void loop()
{
byte a;
if ( shield.available() > 0 ) // if there is data coming into the serial line
{
a = shield.read(); // get the byte of data
if(gps.encode(a)) // if there is valid GPS data...
{
getgps(gps); // grab the data and display it on the LCD
}
}
}This will append the data to a text file whose name is determine in line 34 of the sketch. If you are using a different GPS shield or a separate SD card shield you may need to change the digital pin value for the chip select line, which is found in lines 14 and 18. The data in our example is logged every ten seconds, however you can change the frequency using the delay() function in line 73.
When you’re ready to start capturing data, simply insert the card and power up the hardware. It will carry on until you turn it off, at which point the data file can be examined on a PC. As an example capture, I took the hardware for a drive, and ended with a file containing much data – for example:
For a more graphical result, you can import the data using a third-party service into Google Maps to get a better idea of the journey. But first, the text file requires a little work. Open it as a text file using a typical spreadsheet, which will then ask how to organise the columns. Delimit them with a space, for example:
Which will give you a spreadsheet of the data. Now delete all the columns except for the latitude and longitude data, and add a header row as such:
Now save that file as an .xls spreadsheet. Next, visit the GPS Visuliser website, and upload the file using the box in the centre of the page. Select “Google Maps” as the output format, and your trip will be presented – for example:
There are many options on the visualiser site, so if you end up using it a lot – consider giving them a donation.
Conclusion
Now you have some easy example sketches that demonstrate how to extract and work with data from your GPS shield. For the curious, the static GPS locations displayed in this tutorial are not our current location. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.
Have fun and keep checking into
tronixstuff.com. Why not follow things on
twitter,
Google+, subscribe for email updates or RSS using the links on the right-hand column, or join our
forum – dedicated to the projects and related items on this website.
Sign up – it’s free, helpful to each other – and we can all learn something.
The post Tutorial – Arduino and MediaTek 3329 GPS appeared first on tronixstuff.
Update 2014 Feb 6: Q1 is intended to be an NPN phototransistor, not PNP as shown here!
