GPS module Interfacing with 8051


Global Positioning System (GPS) makes use of signals sent by satellites in space and ground stations on Earth to accurately determine their position on Earth.

Radio Frequency signals sent from satellites and ground stations are received by the GPS. GPS makes use of these signals to determine its exact position.

The GPS itself does not need to transmit any information.

The signals received from the satellites and ground stations contain timestamps of the time when the signals were transmitted. By calculating the time difference between the time the signal was transmitted and the time the signal was received, and using the speed of the signal, the distance between the satellites and the GPS can be determined using a simple formula for distance using speed and time.

Using information from 3 or more satellites, the exact position of the GPS can be triangulated.

For more information about GPS and how to use it, refer to the topic GPS Receiver Module in the sensors and modules section.

The GPS receiver module uses USART communication to communicate with the controller or PC terminal.

For information about UART in 8051 and how to use it, refer to the topic UART in 8051in the 8051 inside section.

GPS Receiver Module

GPS Receiver Module

Interfacing Diagram

ATmega interfacing with GPS module

GPS module Interfacing with 8051


Now let’s interface the GPS receiver module with 8051 and display the Time, Latitude, and Longitude on the LCD20x4 display.

In this interfacing, the AT89S52 microcontroller is used which will read data serially from GPS receiver using USART communication with 9600 formats.

Then parse the “$GPGGA” string to extract information regarding time, latitude, and longitude.

The Latitude and Longitude displayed on LCD20x4 are in Degree Decimal format.


    GPS Information extraction using 8051

#include "LCD_20x4_H_file.h"
#include "USART_Interrupt.h"

unsigned long int get_gpstime();
float get_latitude(unsigned char);
float get_longitude(unsigned char);
float get_altitude(unsigned char);
void convert_time_to_UTC(unsigned long int);
float convert_to_degrees(float raw);

#define GGA_Buffer_Size 80
#define GGA_Pointers_Size 20

char idata GGA_Buffer[GGA_Buffer_Size];              /* to store GGA string */
char idata GGA_CODE[3];
idata unsigned char GGA_Pointers[GGA_Pointers_Size]; /* to store instances of ',' */
char CommaCounter;
idata char Data_Buffer[15];
volatile unsigned int GGA_Index;
unsigned char	IsItGGAString	= 0;

void main(void) {
	unsigned long int Time;
	float Latitude,Longitude,Altitude;
	char GPS_Buffer[15];
	Ext_int_Init();                      /* enable interrupt */
  while (1){
	       LCD_String_xy(1,0,"UTC Time: ");
	       Time = get_gpstime();            /* Extract Time */
	       convert_time_to_UTC(Time); /* convert time to UTC */
	       LCD_String("  ");
	       LCD_String_xy(2,0,"Lat: ");
	       Latitude = get_latitude(GGA_Pointers[0]); /* Extract Latitude */
	       Latitude = convert_to_degrees(Latitude);  /* convert raw latitude in degree decimal*/
	       sprintf(GPS_Buffer,"%.05f",Latitude);/* convert float value to string */
	       LCD_String(GPS_Buffer);            /* display latitude in degree */
	       LCD_String_xy(3,0,"Long: ");
	       Longitude = get_longitude(GGA_Pointers[2]);/* Extract Latitude */
	       Longitude = convert_to_degrees(Longitude);/* convert raw longitude in degree decimal*/
	       sprintf(GPS_Buffer,"%.05f",Longitude);/* convert float value to string */
	       LCD_String(GPS_Buffer);               /* display latitude in degree */
	       LCD_String_xy(4,0,"Alt: ");
	       Altitude = get_altitude(GGA_Pointers[7]); /* Extract Latitude */
	       sprintf(GPS_Buffer,"%.2f",Altitude);/* convert float value to string */
	       LCD_String(GPS_Buffer);            /* display latitude in degree */


unsigned long int get_gpstime(){
	unsigned char index;
	unsigned char Time_Buffer[15];
	unsigned long int _Time;
	/* parse Time in GGA string stored in buffer */
	for(index = 0;GGA_Buffer[index]!=','; index++){		
		Time_Buffer[index] = GGA_Buffer[index];
	_Time= atol(Time_Buffer);        /* convert string of Time to integer */
	return _Time;                    /* return integer raw value of Time */        

float get_latitude(char lat_pointer){
	unsigned char lat_index = lat_pointer+1;   /* index pointing to the latitude */
	unsigned char index = 0;
	char Lat_Buffer[15];
	float _latitude;

	/* parse Latitude in GGA string stored in buffer */
		Lat_Buffer[index]= GGA_Buffer[lat_index];
	_latitude = atof(Lat_Buffer);     /* convert string of latitude to float */
	return _latitude;                 /* return float raw value of Latitude */

float get_longitude(unsigned char long_pointer){
	unsigned char long_index;
	unsigned char index = long_pointer+1;	/* index pointing to the longitude */
	char Long_Buffer[15];
	float _longitude;
	/* parse Longitude in GGA string stored in buffer */
	for( ; GGA_Buffer[index]!=','; index++){
		Long_Buffer[long_index]= GGA_Buffer[index];
	_longitude = atof(Long_Buffer);    /* convert string of longitude to float */
	return _longitude;                 /* return float raw value of Longitude */

float get_altitude(unsigned char alt_pointer){
	unsigned char alt_index;
	unsigned char index = alt_pointer+1;	/* index pointing to the altitude */
	char Alt_Buffer[12];
	float _Altitude;
	/* parse Altitude in GGA string stored in buffer */
	for( ; GGA_Buffer[index]!=','; index++){
		Alt_Buffer[alt_index]= GGA_Buffer[index];
		_Altitude = atof(Alt_Buffer);   /* convert string of altitude to float */ 
	        return _Altitude;               /* return float raw value of Altitude */

void convert_time_to_UTC(unsigned long int UTC_Time)
	unsigned int hour, min, sec;
	hour = (UTC_Time / 10000);              /* extract hour from integer */
	min = (UTC_Time % 10000) / 100;         /* extract minute from integer */
	sec = (UTC_Time % 10000) % 100;         /* extract second from integer*/

	sprintf(Data_Buffer, "%d:%d:%d", hour,min,sec); /* store UTC time in buffer */

float convert_to_degrees(float raw){
	double value;
	float decimal_value,temp;
	long int degrees;
	float position;
	value = raw;
	/* convert raw latitude/longitude into degree format */
	decimal_value = (value/100);
	degrees = (int)(decimal_value);
	temp = (decimal_value - (int)decimal_value)/0.6; 
	position = (float)degrees + temp;
	return position;	/* return float value in degrees */

void Serial_ISR() interrupt 4    
	unsigned char received_char;
			EA  = 0;		/* Disable global interrupt */
			received_char = SBUF;	

		if(received_char =='$'){        /* check for '$' */
			GGA_Index = 0;
			IsItGGAString = 0;
			CommaCounter = 0;
		else if(IsItGGAString == 1){    /* if true save GGA info. into buffer */
			if(received_char == ',' ) 
                           GGA_Pointers[CommaCounter++] = GGA_Index;    /* store instances of ',' in buffer */
			GGA_Buffer[GGA_Index++] = received_char;
		else if(GGA_CODE[0] == 'G' && GGA_CODE[1] == 'G' && GGA_CODE[2] == 'A'){ /* check for GGA string */
			IsItGGAString = 1;
			GGA_CODE[0] = 0; GGA_CODE[1] = 0; GGA_CODE[2] = 0;
			GGA_CODE[0] = GGA_CODE[1];  GGA_CODE[1] = GGA_CODE[2]; GGA_CODE[2] = received_char; 
		RI = 0;		/* Clear RI flag */
		EA = 1;         /* enable interrupt */



How to Calculate Latitude and Longitude in GPS coordinates form

We get latitude and Longitude from the GGA string which is in the form of ddmm.mmmm and dddmm.mmmm respectively.


d – degree

m – minutes

Now, we can convert received latitude and longitude string in DMS (Degree Minute Second) and Degree Decimal.

DMS – [dd]degree, [mm] minutes,[(.mmmm)*60] seconds

DegreeDecimal–[dd]degree + (mm.mmmm/60)


Suppose, We have the following Lat/Long data in NMEA format

Latitude – 1829.9639

Longitude – 07347.6174

Now, convert them in the following format,

DMS – 18° degree 29 minutes 57.834 seconds

Degree - 18.499398



Components Used

Ublox NEO-6m GPS
Ublox Neo 6m GPS
8051 AT89c51
8051 AT89c51
LCD16x2 Display
LCD16x2 Display


GPS_Basics Download
NMEA_Reference_Manual Download
8051_Interfacing_With_GPS_Keil_Project Download