WaspGPS Class Reference

WaspGPS Class. More...

#include <WaspGPS.h>

Public Member Functions
	WaspGPS ()
	class constructor
void	ON ()
	It opens UART1 and powers the GPS module.
void	OFF ()
	It closes UART1 and powers off the GPS module.
void	begin (void)
	It powers up GPS module and opens UART1 to communicate with it.
void	close (void)
	It closes UART1.
void	init (void)
	It initializes GPS module with the default values.
void	init (const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *)
	It initializes GPS module with the values introduced as parameters.
void	setMode (uint8_t)
	It sets the current internal Power Mode on the GPS.
uint8_t	getMode (void)
	It gets the current internal Power Mode on the GPS.
bool	check ()
	It checks if the receiver is connected to sattelites.
char *	getTime (void)
	It gets the current time given by GPS.
char *	getDate (void)
	It gets the current date given by GPS.
char *	getLatitude (void)
	It gets the Latitude from the GPS.
char *	getLongitude (void)
	It gets the Longitude from the GPS.
char *	getSpeed (void)
	It gets the Speed from the GPS.
char *	getAltitude (void)
	It gets the Altitude from the GPS.
char *	getCourse (void)
	It gets the Course from the GPS.
uint8_t	saveEphems ()
	It saves ephemeris into a file in the SD card. This file is called 'FILE_EPHEMERIS'.
uint8_t	saveEphems (const char *filename)
	It saves ephemeris into a file in the SD card.
uint8_t	loadEphems ()
	It loads ephemeris from the SD card to the GPS receiver. It loads from file called 'FILE_EPHEMERIS'.
uint8_t	loadEphems (const char *filename)
	It loads ephemeris from the SD card to the GPS receiver.
const char *	getLibVersion (void)
	It gets the library version.
uint8_t	setCommMode (uint16_t)
	It sets communication mode: Binary or NMEA.
uint8_t	getCommMode (void)
	It gets the communication mode on use.
uint8_t	getPosition ()
	It gets the latitude, longitude, altitude, speed, course, time and date.
Data Fields
long	_baudRate
	Variable : Baudrate used to init the UART and communicate with GPS receiver.
uint8_t	_uart
	Variable : UART used to communicate with GPS receiver.
bool	fixValid
	Variable : Determines whether the last reading was valid or not.
uint16_t	flag
	Variable : Flag used to determine if an error occurred while executing some function.
uint16_t	commMode
	Variable : Communication mode. Two possibilities available --> binary mode or NMEA mode.
uint8_t	pwrMode
	Variable : Power mode used for GPS receiver.
uint8_t	wakeMode
	Variable : Waking up mode used for GPS receiver.
char	timeGPS [MAX_ARGS]
	Variable : Time extracted from NMEA GGA sentence received from GPS receiver.
char	dateGPS [MAX_ARGS]
	Variable : Date extracted from NMEA RMC sentence received from GPS receiver.
char *	clkOffset
	Variable : Clock drift of the GPS receiver used to initialize it.
char *	timeOfWeek
	Variable : GPS Time of Week used to initialize it.
char *	weekNo
	Variable : Extended GPS Week Number used to initialize it.
char *	channel
	Variable : Channel Counter used to initialize it.
char *	resetCfg
	Variable : Reset Configuration.
char *	coordinateLat
	Variable : Default Latitude. + = North (Range 90 to -90). Expressed in degrees. Example-->37.3875111.
char *	coordinateLon
	Variable : Default Longitude. + = East (Range 180 to -180). Expressed in degrees. Example-->-121.97232.
char *	coordinateAl
	Variable : Default Altitude position. Expressed in meters. Example-->0.
uint8_t	checksum
	Variable : the frame checksum.
char	latitude [MAX_ARGS]
	Variable : it stores the latitude given by the GPS module.
char	longitude [MAX_ARGS]
	Variable : it stores the longitude given by the GPS module.
char	speed [MAX_ARGS]
	Variable : it stores the speed given by the GPS module.
char	altitude [MAX_ARGS]
	Variable : it stores the altitude given by the GPS module.
char	course [MAX_ARGS]
	Variable : it stores the course given by the GPS module.
uint8_t	reboot
	Variable : for rebooting the GPS module.
uint8_t	checkSUM [2]
	Variable : for storing the frame checksum.
Private Member Functions
void	extractDate (void)
	It extracts Date from a NMEA RMC sentence.
void	extractTime (void)
	It extracts Time from a NMEA GGA sentence.
long	parse_decimal (char *str)
	It extracts a decimal number from a string.
unsigned long	parse_degrees (char *str)
	It extracts a degree number from a string.
long	gpsatol (char *str)
	It extracts a decimal number from a string, getting the integer part of a float number in case.
bool	gpsisdigit (char c)
	It specifies if a char is a number.
uint8_t	checkSum (const char *gpsString)
	It calculates the NMEA checkSum, leave out $, *, and the checkSum bytes.
uint8_t	getChecksum (const char *gpsString)
	It calculates the NMEA checkSum, leave out $, *, and the checkSum bytes.
void	setChecksum ()
	It sets checksum to the end of Utils.inBuffer.
void	getChecksum (uint8_t *buffer)
	It calculates checksum for a secuence given as a parameter.
bool	dataValid (void)
	It gets if the last reading of data was valid or not.
char *	getRaw (int)
	It gets a data string from the GPS.

---

Detailed Description

WaspGPS Class.

WaspGPS Class defines all the variables and functions used to manage GPS A1084 receiver

Definition at line 293 of file WaspGPS.h.

---

Constructor & Destructor Documentation

WaspGPS::WaspGPS

(

)

class constructor

It initializes the variables with the default values.

Parameters:

void

Returns:

void

Definition at line 40 of file WaspGPS.cpp.

References _baudRate, _uart, ACK, channel, checksum, clkOffset, COLD, commMode, coordinateAl, coordinateLat, coordinateLon, flag, GPS_NMEA, GPS_ON, pwrMode, reboot, resetCfg, timeOfWeek, wakeMode, and weekNo.

{
  _baudRate = 4800;     // by default we choose NMEA's speed for the port
  //_baudRate = 9600;   // by default we choose NMEA's speed for the port
  _uart=1;

  // basic GPS configuration
  reboot=COLD;                  // reboot the system or init the system the first time
  flag = ACK;                   // init the flag at ACK
  commMode = GPS_NMEA;          // communication mode: software or hardware serial
  pwrMode = GPS_ON;             // power on the GPS
  wakeMode = COLD;              // wake up erasing the internal data
  clkOffset= (char*) "96000";
  timeOfWeek= (char*) "497260";
  weekNo= (char*) "921";
  channel= (char*) "12";
  resetCfg= (char*) "1";
  coordinateLat = (char*) "4140.8217"; // Zaragoza, Spain, coordinates for Libelium
  coordinateLon = (char*) "00053.1736"; // Zaragoza, Spain, coordinates for Libelium
  coordinateAl = (char*) "198"; // Zaragoza, Spain, coordinates for Libelium
  checksum=0;
}

---

Member Function Documentation

void WaspGPS::extractDate

(

void

)

[private]

It extracts Date from a NMEA RMC sentence.

Parameters:

void

Returns:

void

See also:

extractTime(), getTime(), getDate()

Definition at line 84 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, dateGPS, delay(), flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_RMC, WaspUtils::inBuffer, MAX_ARGS, millis(), serialFlush(), setCommMode(), WaspUtils::strExplode(), and Utils.

Referenced by getDate().

{
  // store current state to return to it later
        uint16_t currentSentences = commMode;
        long previous=0;

        
  // get Date information
        serialFlush(1);
        previous=millis();
        while(!setCommMode(GPS_NMEA_RMC) && (millis()-previous)<3000);
        Utils.strExplode(Utils.inBuffer, ',');       // separates all the subarrays from Utils.inBuffer into the Utils.arguments array
        if( !strcmp(Utils.arguments[0],"$GPRMC") ) 
        {
                for(int i=0;i<MAX_ARGS;i++) dateGPS[i]=Utils.arguments[9][i];
        }
        else
        {
                flag |=GPS_INVALID;
        }

  // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspGPS::extractTime

(

void

)

[private]

It extracts Time from a NMEA GGA sentence.

Parameters:

void

Returns:

void

See also:

extractTime(), getTime(), getDate()

Definition at line 124 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, delay(), flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_GGA, WaspUtils::inBuffer, MAX_ARGS, millis(), serialFlush(), setCommMode(), WaspUtils::strExplode(), timeGPS, and Utils.

Referenced by getTime().

{
        // store current state to return to it later
        uint16_t currentSentences = commMode;
        long previous=0;

        // get Time
        serialFlush(1);
        previous=millis();
        while(!setCommMode(GPS_NMEA_GGA) && (millis()-previous)<3000);
        Utils.strExplode(Utils.inBuffer, ',');       // separates all the subarrays from Utils.inBuffer into the Utils.arguments array
        if( !strcmp(Utils.arguments[0],"$GPGGA") ) 
        {
                for(int i=0;i<MAX_ARGS;i++) timeGPS[i]=Utils.arguments[1][i];
        }
        else
        {
                flag |= GPS_INVALID;
        }

  // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

long WaspGPS::parse_decimal

(

char *

str

)

[private]

It extracts a decimal number from a string.

Parameters:

char

*str: The string which contains the decimal number to extract

Returns:

the number extracted from the string given as parameter.

See also:

extractTime(), getTime(), getDate(), parse_degrees(char *str), gpsatol(char *str), gpsisdigit(char c)

Definition at line 158 of file WaspGPS.cpp.

References gpsatol(), and gpsisdigit().

{
        bool isneg = *str == '-';
        if (isneg) *str++;
        unsigned long ret = 100UL * gpsatol(str);
        while (gpsisdigit(*str)) ++str;
        if (*str == '.')
        {
                if (gpsisdigit(str[1]))
                {
                        ret += 10 * (str[1] - '0');
                        if (gpsisdigit(str[2]))
                                ret += str[2] - '0';
                }
        }
        return isneg ? -ret : ret;
}

Here is the call graph for this function:

unsigned long WaspGPS::parse_degrees

(

char *

str

)

[private]

It extracts a degree number from a string.

Parameters:

char

*str: The string which contains the degree number to extract

Returns:

the number extracted from the string given as parameter.

See also:

extractTime(), getTime(), getDate(), parse_degrees(char *str), gpsatol(char *str), gpsisdigit(char c)

Definition at line 181 of file WaspGPS.cpp.

References gpsatol(), and gpsisdigit().

{
        unsigned long left = gpsatol(str);
        unsigned long tenk_minutes = (left % 100UL) * 10000UL;
        while (gpsisdigit(*str)) ++str;
        if (*str == '.')
        {
                unsigned long mult = 1000;
                while (gpsisdigit(*++str))
                {
                        tenk_minutes += mult * (*str - '0');
                        mult /= 10;
                }
        }
        return (left / 100) * 100000 + tenk_minutes / 6;
}

Here is the call graph for this function:

long WaspGPS::gpsatol

(

char *

str

)

[private]

It extracts a decimal number from a string, getting the integer part of a float number in case.

Parameters:

char

*str: The string which contains the decimal or float number to extract

Returns:

the number extracted from the string given as parameter.

See also:

extractTime(), getTime(), getDate(), parse_degrees(char *str), gpsatol(char *str), gpsisdigit(char c)

Definition at line 203 of file WaspGPS.cpp.

References gpsisdigit().

Referenced by parse_decimal(), and parse_degrees().

{
        long ret = 0;
        while (gpsisdigit(*str))
                ret = 10 * ret + *str++ - '0';
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WaspGPS::gpsisdigit

(

char

c

)

[inline, private]

It specifies if a char is a number.

Parameters:

char

c: The char to get if it is a number

Returns:

TRUE if a number, FALSE if not

See also:

extractTime(), getTime(), getDate(), parse_degrees(char *str), gpsatol(char *str), gpsisdigit(char c)

Definition at line 343 of file WaspGPS.h.

Referenced by gpsatol(), parse_decimal(), and parse_degrees().

{ return c >= '0' && c <= '9'; };

Here is the caller graph for this function:

uint8_t WaspGPS::checkSum

(

const char *

gpsString

)

[private]

It calculates the NMEA checkSum, leave out $, *, and the checkSum bytes.

Parameters:

char

*gpsString: the string containing the NMEA sentence to get the checksum from

Returns:

'1' if checksum is correct, '0' if not

Definition at line 1289 of file WaspGPS.cpp.

References check(), flag, GPS_BAD_CHECKSUM, WaspUtils::sizeOf(), and Utils.

{
  // clear the checksum flag
  flag &= ~(GPS_BAD_CHECKSUM);

  // return error if there is no asterisk at the end of the string
  if (gpsString[Utils.sizeOf(gpsString)-3] != '*') return 0;

  char check = 0;
  // iterate over the string, XOR each byte with the total sum:
  for (int c = 1; c < Utils.sizeOf(gpsString) - 3; c++) {
    check = char(check ^ gpsString[c]);
  }

  // get the checksum character for the string itself
  char stringCheckSum = (gpsString[Utils.sizeOf(gpsString)-2] - '0') << 4 | (gpsString[Utils.sizeOf(gpsString)-1] - '0');
 
  uint8_t result = (check == stringCheckSum);

  if (!result) flag |= GPS_BAD_CHECKSUM;

  // return the result
  return result;
}

Here is the call graph for this function:

uint8_t WaspGPS::getChecksum

(

const char *

gpsString

)

[private]

It calculates the NMEA checkSum, leave out $, *, and the checkSum bytes.

Parameters:

char

*gpsString: the string containing the NMEA sentence to get the checksum from

Returns:

'1' if checksum is correct, '0' if not

See also:

setChecksum()

Definition at line 1321 of file WaspGPS.cpp.

References check(), WaspUtils::sizeOf(), and Utils.

Referenced by loadEphems(), saveEphems(), and setChecksum().

{
  char check = 0;
  // iterate over the string, XOR each byte with the total sum:
  for (int c = 1; c < Utils.sizeOf(gpsString) - 3; c++) {
    check = char(check ^ gpsString[c]);
  }
  return check;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspGPS::setChecksum

(

)

[private]

It sets checksum to the end of Utils.inBuffer.

Parameters:

void

Returns:

void

See also:

init()

Definition at line 1336 of file WaspGPS.cpp.

References checksum, getChecksum(), WaspUtils::inBuffer, WaspUtils::sizeOf(), and Utils.

Referenced by init().

{
        checksum= getChecksum(Utils.inBuffer);
        int aux=Utils.sizeOf(Utils.inBuffer);
        float aux2 = checksum%16;
        if(aux2==0.0)
        {
                Utils.inBuffer[aux-1]=48;
                Utils.inBuffer[aux-2]=(checksum/16)+48;
        }
        else
        {
                Utils.inBuffer[aux-2]=(int) (checksum/16) + 48;
                aux2 = checksum/16;
                Utils.inBuffer[aux-1]= (checksum-aux2*16)+48;
                
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspGPS::getChecksum

(

uint8_t *

buffer

)

[private]

It calculates checksum for a secuence given as a parameter.

Parameters:

uint8_t*

buffer: the secuence to get the checksum from

Returns:

void. It stores in 'checkSUM' variable the result

See also:

saveEphems()

Definition at line 892 of file WaspGPS.cpp.

References check(), and checkSUM.

{
        int a=4;
        int check=0;
        uint8_t aux=0, aux2=0;
        while( (buffer[aux]!=0xB0) || (buffer[aux+1]!=0xB3) )
        {
                aux++;
        }
        buffer[aux-1]=0x00;
        buffer[aux-2]=0x00;
        aux=0;
        while( (buffer[a]!=0xB0) || (buffer[a+1]!=0xB3) )
        {
                check+=buffer[a];
                check &= 0x7FFF;
                a++;
        }
        if(check>255)
        {
                aux=check/256;
                aux2=check-(aux*256);
                checkSUM[0]=aux;
                checkSUM[1]=aux2;
        }
        else
        {
                checkSUM[0]=0x00;
                checkSUM[1]=check;
        }
}

Here is the call graph for this function:

bool WaspGPS::dataValid

(

void

)

[inline, private]

It gets if the last reading of data was valid or not.

Parameters:

void

Returns:

'TRUE' if valid, 'FALSE' if not

Definition at line 381 of file WaspGPS.h.

References fixValid.

{return fixValid;};

char * WaspGPS::getRaw

(

int

byteAmount

)

[private]

It gets a data string from the GPS.

Parameters:

int

byteAmount: the number of bytes to read from GPS

Returns:

char*. It retunrs 'Utils.inBuffer', where the data read from GPS has been parsed and stored

See also:

extractDate(), extractTime(), setCommMode(mode), check(), getLatitude(), getLongitude(), getAltitude(),getSpeed(), getCourse()

Definition at line 811 of file WaspGPS.cpp.

References _uart, WaspUtils::clearBuffer(), delay(), flag, GPS_BUFFER_SIZE, GPS_TIMEOUT, GPS_TIMEOUT_em, WaspUtils::inBuffer, serialAvailable(), serialFlush(), serialRead(), and Utils.

Referenced by setCommMode().

{
  flag &= ~(GPS_TIMEOUT);

  uint8_t byteGPS = 0;          // the last byte coming through the port
  int i = 0;                    // count the amount of bytes read
  uint32_t timeout = 1000;      // millis to wait before declaring timeout

  if (byteAmount == 0) byteAmount = GPS_BUFFER_SIZE;
  
  serialFlush(1);       // empty the port
  Utils.clearBuffer();
  // wait until arrival of a byte
  while(!serialAvailable(_uart) && timeout > 0) { delay(1); timeout--; };       

  if (timeout <= 0)
  {
    flag |= GPS_TIMEOUT;
    return GPS_TIMEOUT_em;
  }

  byteGPS = serialRead(_uart);  // read the first byte coming through the port         

  while(byteGPS != '$')
  { 
    if(serialAvailable(_uart) > 0) 
      byteGPS = serialRead(_uart); // flush incomplete sentences
  }
  Utils.inBuffer[i]=byteGPS;  
  i++;
  while(i <= 1 || (byteGPS != '*' && byteGPS != '$' && i < byteAmount)){ // read the GPS sentence
//  while(!i || (byteGPS != '*' && byteGPS != '$' && i < byteAmount)){ // read the GPS sentence
          if(serialAvailable(_uart) > 0)
    {
      byteGPS = serialRead(_uart);
      if (byteGPS != '*' && byteGPS != '$' && i < byteAmount) Utils.inBuffer[i]=byteGPS;               
/*      if (byteGPS != '$' && i < byteAmount) Utils.inBuffer[i]=byteGPS;               */
      i++;
    }  
   }
//   // add the checksum
//   if (byteGPS == '*' && i < byteAmount) 
//   {
//     timeout = 1000;
//     while(!serialAvailable(1) && timeout > 0) { delay(1); timeout--; };
//     if (timeout <= 0)
//     {
//       flag |= GPS_TIMEOUT;
//       return GPS_TIMEOUT_em;
//     }
//     byteGPS = serialRead(_uart);     
//     Utils.inBuffer[i]=byteGPS;
//     i++;
//     if (i < byteAmount) 
//     {
//       timeout = 1000;
//       while(!serialAvailable(1) && timeout > 0) { delay(1); timeout--; };
//       if (timeout <= 0)
//       {
//         flag |= GPS_TIMEOUT;
//         return GPS_TIMEOUT_em;
//       }
//       byteGPS = serialRead(_uart);   
//       Utils.inBuffer[i]=byteGPS;
//       i++;
//     }
//   }

  if (byteGPS == '\n' || i == byteAmount) Utils.inBuffer[i-1] = '\0';  
  else Utils.inBuffer[i] = '\0';
  
  return Utils.inBuffer; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspGPS::ON

(

void

)

It opens UART1 and powers the GPS module.

Parameters:

void

Returns:

void

See also:

close(), begin()

Definition at line 222 of file WaspGPS.cpp.

References begin(), GPS_ON, init(), and setMode().

{
        setMode(GPS_ON);
        begin();
        init();
}

Here is the call graph for this function:

void WaspGPS::OFF

(

)

It closes UART1 and powers off the GPS module.

Parameters:

void

Returns:

void

See also:

close(), begin()

Definition at line 235 of file WaspGPS.cpp.

References close(), GPS_OFF, and setMode().

{
        close();
        setMode(GPS_OFF);
}

Here is the call graph for this function:

void WaspGPS::begin

(

void

)

It powers up GPS module and opens UART1 to communicate with it.

Parameters:

void

Returns:

void

See also:

init()

Definition at line 1255 of file WaspGPS.cpp.

References _baudRate, _uart, beginSerial(), WaspUtils::setMuxGPS(), and Utils.

Referenced by init(), and ON().

{
  Utils.setMuxGPS();
  beginSerial(_baudRate,_uart);

}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspGPS::close

(

void

)

It closes UART1.

Parameters:

void

Returns:

void

Definition at line 1275 of file WaspGPS.cpp.

References _uart, closeSerial(), COLD, MUX_TO_LOW, reboot, WaspUtils::setMux(), and Utils.

Referenced by OFF().

{
  closeSerial(_uart);
  Utils.setMux(MUX_TO_LOW,MUX_TO_LOW);
  reboot=COLD;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WaspGPS::init

(

void

)

It initializes GPS module with the default values.

Parameters:

void

Returns:

void

See also:

init(const char*, const char*, const char*, const char*, const char*, const char*, const char*, const char*)

Definition at line 252 of file WaspGPS.cpp.

References channel, clkOffset, coordinateAl, coordinateLat, coordinateLon, resetCfg, timeOfWeek, and weekNo.

Referenced by ON().

{
        init(coordinateLat, coordinateLon, coordinateAl, clkOffset, timeOfWeek, weekNo, channel, resetCfg);
}

Here is the caller graph for this function:

void WaspGPS::init	(	const char *	_coordinateLat,
		const char *	_coordinateLon,
		const char *	_coordinateAl,
		const char *	_clkOffset,
		const char *	_timeOfWeek,
		const char *	_weekNo,
		const char *	_channel,
		const char *	_resetCfg
	)

It initializes GPS module with the values introduced as parameters.

Parameters:

	const	char* _coordinateLat : Latitude + = North (Range 90 to -90). Expressed in degrees. Example-->37.3875111
	const	char* _coordinateLon : Longitude + = East (Range 180 to -180). Expressed in degrees. Example-->-121.97232
	const	char* _coordinateAl : Altitude position. Expressed in meters. Example-->0
	const	char* _clkOffset : Clock Drift of the Receiver. Expressed in Hz. Example-->96000
	const	char* _timeOfWeek : GPS Time Of Week. Expressed in seconds. Example-->237759
	const	char* _weekNo : Extended GPS Week Number. Example-->1946
	const	char* _channel : Range 1 to 12
	const	char* _resetCfg : Reset Configuration Bit

Returns:

void

See also:

init()

Definition at line 267 of file WaspGPS.cpp.

References begin(), delay(), GPS_BINARY, GPS_BINARY_OFF, HOT, WaspUtils::inBuffer, millis(), printByte(), printString(), reboot, serialFlush(), setChecksum(), setCommMode(), and Utils.

{
        long previous=0;
  // set up the initial coordinates, time and date
  if(reboot)
  {
      begin();
      delay(3000); 
  }
  sprintf(Utils.inBuffer,"$PSRF104,%s,%s,%s,%s,%s,%s,%s,%s*00",_coordinateLat,_coordinateLon,_coordinateAl,_clkOffset,_timeOfWeek,_weekNo,_channel,_resetCfg);
  
  setChecksum();
  serialFlush(1);
  printString(Utils.inBuffer,1);
  printByte('\r',1);
  printByte('\n',1);
  
  // Set GPS on binary mode without sending data
  
  previous=millis();
  while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);
  previous=millis();
  while(!setCommMode(GPS_BINARY_OFF) && (millis()-previous)<3000);
  serialFlush(1);
  reboot=HOT;
}

Here is the call graph for this function:

void WaspGPS::setMode

(

uint8_t

mode

)

It sets the current internal Power Mode on the GPS.

Parameters:

uint8_t

mode : power mode to set the GPS. Possible values are GPS_ON, GPS_OFF

Returns:

void

See also:

getMode()

Definition at line 469 of file WaspGPS.cpp.

References digitalWrite(), GPS_OFF, GPS_ON, GPS_PW, HIGH, LOW, OUTPUT, pinMode(), and pwrMode.

Referenced by OFF(), and ON().

{
        pwrMode = mode;
        pinMode(GPS_PW,OUTPUT);
        
  // set the GPS in the defined power mode
        switch (pwrMode)
        {
                case GPS_ON:
                        digitalWrite(GPS_PW,HIGH);
                        break;

                case GPS_OFF:
                        digitalWrite(GPS_PW,LOW);
                        break;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspGPS::getMode

(

void

)

It gets the current internal Power Mode on the GPS.

Parameters:

void

Returns:

'pwrMode' variable that contains the power mode on use

See also:

setMode()

Definition at line 495 of file WaspGPS.cpp.

References pwrMode.

{
        return pwrMode;
}

bool WaspGPS::check

(

void

)

It checks if the receiver is connected to sattelites.

Parameters:

void

Returns:

'1' if connected, '0' if not.

See also:

init()

Definition at line 507 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, delay(), GPS_BINARY, GPS_BINARY_OFF, GPS_NMEA_GGA, WaspUtils::inBuffer, millis(), serialFlush(), setCommMode(), WaspUtils::strExplode(), and Utils.

Referenced by checkSum(), and getChecksum().

{
        uint16_t currentSentences = commMode;
        bool connection=0;
        long previous=0;
                
        serialFlush(1);
        while(!setCommMode(GPS_NMEA_GGA) && (millis()-previous)<3000);
        
        // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
        Utils.strExplode(Utils.inBuffer, ',');
                
        // the data is valid only if the GPGGA position 7 is 1 or bigger
        if( !strcmp(Utils.arguments[0],"$GPGGA") ) 
        {
                connection = (Utils.arguments[6][0] - '0');
        }
        else connection=0;

        // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);
        
        return connection;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * WaspGPS::getTime

(

void

)

It gets the current time given by GPS.

Parameters:

void

Returns:

the currect time in a string with the following structure--> "hhmmss.mmmm"

See also:

getDate(), extractTime(), extractDate()

Definition at line 545 of file WaspGPS.cpp.

References extractTime(), and timeGPS.

{
  extractTime();
  return timeGPS;
}

Here is the call graph for this function:

char * WaspGPS::getDate

(

void

)

It gets the current date given by GPS.

Parameters:

void

Returns:

the currect date in a string with the following structure--> "ddmmyy"

See also:

getDate(), extractTime(), extractDate()

Definition at line 560 of file WaspGPS.cpp.

References dateGPS, and extractDate().

{
  extractDate();
  return dateGPS;
}

Here is the call graph for this function:

char * WaspGPS::getLatitude

(

void

)

It gets the Latitude from the GPS.

Parameters:

void

Returns:

the Latitude in a string, expressed in degrees

See also:

init()

Definition at line 576 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, delay(), fixValid, flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_GGA, WaspUtils::inBuffer, latitude, MAX_ARGS, millis(), setCommMode(), WaspUtils::strExplode(), and Utils.

{       
        flag &= ~(GPS_INVALID);

  // store current state to return to it later
        uint16_t currentSentences = commMode;
        long previous=0;

  // get latitude, longitude, altitude, but NOT time
        while(!setCommMode(GPS_NMEA_GGA) && (millis()-previous)<3000);

  // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
        Utils.strExplode(Utils.inBuffer, ',');       

        if( !strcmp(Utils.arguments[0],"$GPGGA") ) 
        {
                for(int i=0;i<MAX_ARGS;i++) latitude[i]=Utils.arguments[2][i];
        }
        else
        {
                flag |=GPS_INVALID;
        }
        
        
  // the data is valid only if the GPGGA position 7 is 1 or bigger
        fixValid = (Utils.arguments[6][0] - '0');  
        if (!fixValid) flag |= GPS_INVALID;

  // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);

        return latitude;
}

Here is the call graph for this function:

char * WaspGPS::getLongitude

(

void

)

It gets the Longitude from the GPS.

Parameters:

void

Returns:

the Longitude in a string, expressed in degrees

See also:

init()

Definition at line 623 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, delay(), fixValid, flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_GGA, WaspUtils::inBuffer, longitude, MAX_ARGS, millis(), setCommMode(), WaspUtils::strExplode(), and Utils.

{       
        flag &= ~(GPS_INVALID);

  // store current state to return to it later
        uint16_t currentSentences = commMode;
        long previous=0;

  // get latitude, longitude, altitude, but NOT time
        while(!setCommMode(GPS_NMEA_GGA) && (millis()-previous)<3000);

  // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
        Utils.strExplode(Utils.inBuffer, ',');       

        if( !strcmp(Utils.arguments[0],"$GPGGA") ) 
        {
                for(int i=0;i<MAX_ARGS;i++) longitude[i]=Utils.arguments[4][i];
        }
        else
        {
                flag |=GPS_INVALID;
        }
        
  // the data is valid only if the GPGGA position 7 is 1 or bigger
        fixValid = (Utils.arguments[6][0] - '0');  
        if (!fixValid) flag |= GPS_INVALID;

  // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);
        
        return longitude;
}

Here is the call graph for this function:

char * WaspGPS::getSpeed

(

void

)

It gets the Speed from the GPS.

Parameters:

void

Returns:

the Speed in a string, expressed in kilometers per hour

See also:

init()

Definition at line 675 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, delay(), flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_VTG, WaspUtils::inBuffer, MAX_ARGS, millis(), setCommMode(), speed, WaspUtils::strExplode(), and Utils.

{
  // store current state to return to it later
  uint16_t currentSentences = commMode;
  long previous=0;

  // get speed and course
  while(!setCommMode(GPS_NMEA_VTG) && (millis()-previous)<3000);

  // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
  Utils.strExplode(Utils.inBuffer, ',');  

  if( !strcmp(Utils.arguments[0],"$GPVTG") ) 
  {
          for(int i=0;i<MAX_ARGS;i++) speed[i]=Utils.arguments[7][i];
  }
  else
  {
          flag |=GPS_INVALID;
  }

  // return to previous state
  previous=millis();
  if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);        
  delay(100);
  previous=millis();
  while(!setCommMode(currentSentences) && (millis()-previous)<3000);

  return speed;
}

Here is the call graph for this function:

char * WaspGPS::getAltitude

(

void

)

It gets the Altitude from the GPS.

Parameters:

void

Returns:

the Altitude in a string, expressed in meters

See also:

init()

Definition at line 715 of file WaspGPS.cpp.

References altitude, WaspUtils::arguments, commMode, delay(), fixValid, flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_GGA, WaspUtils::inBuffer, MAX_ARGS, millis(), setCommMode(), WaspUtils::strExplode(), and Utils.

{
        flag &= ~(GPS_INVALID);

  // store current state to return to it later
        uint16_t currentSentences = commMode;
        long previous=0;

  // get latitude, longitude, altitude, but NOT time
        while(!setCommMode(GPS_NMEA_GGA) && (millis()-previous)<3000);

  // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
        Utils.strExplode(Utils.inBuffer, ',');       

        if( !strcmp(Utils.arguments[0],"$GPGGA") ) 
        {
                for(int i=0;i<MAX_ARGS;i++) altitude[i]=Utils.arguments[9][i];
        }
        else
        {
                flag |=GPS_INVALID;
        }
        
  // the data is valid only if the GPGGA position 7 is 1 or bigger
        fixValid = (Utils.arguments[6][0] - '0');  
        if (!fixValid) flag |= GPS_INVALID;

  // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);

          return altitude;
}

Here is the call graph for this function:

char * WaspGPS::getCourse

(

void

)

It gets the Course from the GPS.

Parameters:

void

Returns:

the True Track made good, expressed in degrees

See also:

init()

Definition at line 766 of file WaspGPS.cpp.

References WaspUtils::arguments, commMode, course, delay(), flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA_VTG, WaspUtils::inBuffer, MAX_ARGS, millis(), setCommMode(), WaspUtils::strExplode(), and Utils.

{
  // store current state to return to it later
        uint16_t currentSentences = commMode;
        long previous=0;

  // get speed and course
        while(!setCommMode(GPS_NMEA_VTG) && (millis()-previous)<3000);

  // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
        Utils.strExplode(Utils.inBuffer, ',');  

        if( !strcmp(Utils.arguments[0],"$GPVTG") ) 
        {
                for(int i=0;i<MAX_ARGS;i++) course[i]=Utils.arguments[1][i];
        }
        else
        {
                flag |=GPS_INVALID;
        }

  // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);

        return course;
}

Here is the call graph for this function:

uint8_t WaspGPS::saveEphems

(

)

It saves ephemeris into a file in the SD card. This file is called 'FILE_EPHEMERIS'.

Parameters:

void

Returns:

'2' when no ephemeris are returned by GPS receiver, '0' when error on writing and '1' on succesful.

See also:

saveEphems(const char* filemane)

Definition at line 930 of file WaspGPS.cpp.

References FILE_EPHEMERIS.

{
        return saveEphems(FILE_EPHEMERIS);
}

uint8_t WaspGPS::saveEphems

(

const char *

filename

)

It saves ephemeris into a file in the SD card.

Parameters:

const

char* filename : The file name to store ephemeris in

Returns:

'2' when no ephemeris are returned by GPS receiver, '0' when error on writing and '1' on succesful.

See also:

saveEphems()

Definition at line 942 of file WaspGPS.cpp.

References _uart, checkSUM, WaspSD::create(), WaspSD::del(), delay(), WaspSD::flag, flag, getChecksum(), GPS_BINARY_OFF, WaspSD::isFile(), millis(), printByte(), SD, serialAvailable(), serialFlush(), serialRead(), setCommMode(), and WaspSD::writeSD().

{
        uint8_t tempBuffer[11] ={0xA0,0xA2,0x00,0x03,0x93,0x00,0x00,0x00,0x00,0xB0,0xB3};
        uint8_t* ByteIN = (uint8_t*) calloc(110,sizeof(uint8_t));
        uint8_t* tempData = (uint8_t*) calloc(92,sizeof(uint8_t));
        uint8_t endFile[7] ={0xAA,0xBB,0xCC,0xCC,0xBB,0xAA,0xAA};
        uint8_t counter3=0;
        uint8_t end=0;
        uint16_t interval=1000;
        long previous=millis();
        int8_t error=2;
        uint8_t est=1;
        // initialize the flags
        flag = 0; SD.flag = 0;
        uint8_t aux=0;
        
        if (SD.isFile(filename)) SD.del(filename);
        SD.create(filename);
        
        previous=millis();
        while(!setCommMode(GPS_BINARY_OFF) && (millis()-previous)<3000);        
        delay(100);
        while(serialAvailable(_uart)>0)
        {
                serialRead(_uart);
        }
        // Iterates asking the GPS about available ephemeris (0..32)
        for(int a=1;a<33;a++)
        {
                tempBuffer[5]=a; // set SV ID
                getChecksum(tempBuffer);
                tempBuffer[7]=checkSUM[0];
                tempBuffer[8]=checkSUM[1];
                for(int b=0;b<11;b++)
                {
                        printByte(tempBuffer[b],_uart);
                }
                // read ephemeris data and store into ByteIN
                while(end==0)
                {
                        if(serialAvailable(_uart)>0)
                        {
                                ByteIN[counter3]=serialRead(_uart);
                                counter3++;
                                previous=millis();
                        }
                        if( (millis()-previous) > interval )
                        {
                                end=1;
                                serialFlush(_uart);
                        } 
                }
                if( counter3>100 ) // ephemeris available
                {
                        counter3=6;
                        if( (ByteIN[0]!=0xA0) || (ByteIN[1]!=0xA2) ) break;
                        while( counter3<96 )
                        {
                                tempData[counter3-6]=ByteIN[counter3];
                                counter3++;
                        }
                        tempData[counter3]=0xAA;
                        tempData[counter3+1]=0xAA;
                        if(SD.writeSD(filename,tempData,aux*90)) error=1;
                        else error=0;
                        aux++;
                }
                counter3=0;
                end=0;
                previous=millis();
        }
        if (error==1) if(SD.writeSD(filename,endFile,aux*90)) error=1;
        free(ByteIN);
        free(tempData);
        ByteIN=NULL;
        tempData=NULL;
        return error;
}

Here is the call graph for this function:

uint8_t WaspGPS::loadEphems

(

)

It loads ephemeris from the SD card to the GPS receiver. It loads from file called 'FILE_EPHEMERIS'.

Parameters:

void

Returns:

'1' on success and '0' on error.

See also:

loadEphems(const char* filename)

Definition at line 1027 of file WaspGPS.cpp.

References FILE_EPHEMERIS.

{
        return loadEphems(FILE_EPHEMERIS);
}

uint8_t WaspGPS::loadEphems

(

const char *

filename

)

It loads ephemeris from the SD card to the GPS receiver.

Parameters:

const

char* filename : The file name to get the ephemeris from

Returns:

'1' on success and '0' on error.

See also:

loadEphems()

Definition at line 1039 of file WaspGPS.cpp.

References _uart, WaspSD::bufferBin, WaspSD::catBin(), checkSUM, delay(), WaspSD::flag, getChecksum(), GPS_BINARY_OFF, millis(), printByte(), SD, serialAvailable(), serialFlush(), serialRead(), and setCommMode().

{
        uint8_t* tempData = (uint8_t*) calloc(99,sizeof(uint8_t));
        uint8_t* answer = (uint8_t*) calloc(10,sizeof(uint8_t));
        uint8_t endFile=0;
        uint16_t offset=0;
        uint8_t counter3=0;
        uint8_t end=0;
        uint16_t interval=1000;
        long previous=millis();
        int8_t error=2;
        SD.flag = 0;
        
        /*** Disable All Binary Messages ***/
        while(!setCommMode(GPS_BINARY_OFF) && (millis()-previous)<3000);
        delay(100);
        while(serialAvailable(_uart)>0)
        {
                serialRead(_uart);
        }
        while( !endFile )
        {
                SD.catBin(filename,offset,5);
                
                if( (SD.bufferBin[0]==0xAA) && (SD.bufferBin[1]==0xBB) && (SD.bufferBin[2]==0xCC) &&
                                   (SD.bufferBin[3]==0xCC) && (SD.bufferBin[4]==0xBB) ) endFile=1;
                
                if (!endFile)
                {
                        for(int a=0;a<5;a++) // Copy first 5 already read bytes
                        {
                                tempData[a+5]=SD.bufferBin[a];
                        }
                        offset+=5;
                        SD.catBin(filename,offset,85);
                        
                        tempData[0]=0xA0;
                        tempData[1]=0xA2;
                        tempData[2]=0x00;
                        tempData[3]=0x5B;
                        tempData[4]=0x95;
                        for(int b=10;b<95;b++)
                        {
                                tempData[b]=SD.bufferBin[b-10];
                        }
                        tempData[95]=0x00;
                        tempData[96]=0x00;
                        tempData[97]=0xB0;
                        tempData[98]=0xB3;
                        getChecksum(tempData);
                        tempData[95]=checkSUM[0];
                        tempData[96]=checkSUM[1];
                        for(int c=0;c<99;c++)
                        {
                                printByte(tempData[c],_uart);
                        }
                        delay(100);
                        while(end==0)
                        {
                                if(serialAvailable(_uart)>0)
                                {
                                        answer[counter3]=serialRead(_uart);
                                        counter3++;
                                        previous=millis();
                                }
                                if( (millis()-previous) > interval )
                                {
                                        end=1;
                                        serialFlush(_uart);
                                } 
                        }
                        counter3=0;
                        end=0;
                        previous=millis();
                        if( (answer[0]==0xA0) && (answer[1]==0xA2) && (answer[2]==0x00) && (answer[3]==0x02) &&
                                                  (answer[4]==0x0B) && (answer[5]==0x95) && (answer[6]==0x00) &&
                                                  (answer[7]==0xA0) && (answer[8]==0xB0) && (answer[9]==0xB3) ) error=1;
                        else error=0;
                        offset+=85;
                }
        }
        free(answer);
        free(tempData);
        answer=NULL;
        tempData=NULL;
        return error;
        
}

Here is the call graph for this function:

const char* WaspGPS::getLibVersion

(

void

)

[inline]

It gets the library version.

Parameters:

void

Returns:

const char*. The GPS library version.

See also:

init()

Definition at line 737 of file WaspGPS.h.

References VERSION.

{return VERSION;};

uint8_t WaspGPS::setCommMode

(

uint16_t

mode

)

It sets communication mode: Binary or NMEA.

Parameters:

uint16_t

mode : the communication mode. Possible values are GPS_BINARY, GPS_NMEA_GGA, GPS_NMEA_GLL, GPS_NMEA_GSA, GPS_NMEA_GSV, GPS_NMEA_RMC, GPS_NMEA_VTG, GPS_NMEA, GPS_BINARY_OFF

Returns:

'1' on succes, '0' if not

See also:

getCommMode()

Definition at line 299 of file WaspGPS.cpp.

References _baudRate, _uart, WaspUtils::arguments, commMode, delay(), getRaw(), GPS_BINARY, GPS_BINARY_OFF, GPS_NMEA, GPS_NMEA_GGA, GPS_NMEA_GLL, GPS_NMEA_GSA, GPS_NMEA_GSV, GPS_NMEA_RMC, GPS_NMEA_VTG, WaspUtils::inBuffer, printByte(), printString(), serialAvailable(), serialFlush(), serialRead(), WaspUtils::strExplode(), and Utils.

Referenced by check(), extractDate(), extractTime(), getAltitude(), getCourse(), getLatitude(), getLongitude(), getPosition(), getSpeed(), init(), loadEphems(), and saveEphems().

{
  uint8_t tempBuffer[32] =
  {0xA0,0xA2,0x00,0x18,0x81,0x02,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,
  0x00,0x01,0x00,0x01,0x00,0x01,0x12,0xC0,0x01,0x60,0xB0,0xB3};
  uint8_t tempBuffer2[16] ={0xA0,0xA2,0x00,0x08,0xA6,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0xAA,0xB0,0xB3};
  uint8_t byteIN[10];
  commMode = mode;
  uint8_t valid=0;
    
  switch(commMode)
  {
          case GPS_BINARY:      sprintf(Utils.inBuffer,"$PSRF100,0,%u,8,1,0*0F",_baudRate);
                                serialFlush(_uart);
                                printString(Utils.inBuffer,_uart);
                                printByte('\r',_uart);
                                printByte('\n',_uart);
                                delay(10);
                                serialFlush(_uart);
                                delay(10);
                                if(serialAvailable(_uart)){
                                        byteIN[0]=serialRead(_uart);
                                        if( (byteIN[0]=='$') || ( (byteIN[0]>'0') && (byteIN[0]<'Z') ) ) valid=0;
                                        else valid=1;
                                }
                                break;
          case GPS_BINARY_OFF:  serialFlush(_uart);
                                for(int a=0;a<16;a++)
                                {
                                        printByte(tempBuffer2[a],_uart);
                                        //if(a==14) serialFlush(_uart);
                                }
                                delay(100);
                                if(serialAvailable(_uart))
                                {
                                        for(int a=0;a<10;a++)
                                        {
                                                byteIN[a]=serialRead(_uart);
                                        }
                                }
                                if(byteIN[5]==0xA6) valid=1;
                                else valid=0;
                                break;
          case GPS_NMEA:        tempBuffer[8]=0x01;
                                tempBuffer[10]=0x01;
                                tempBuffer[12]=0x01;
                                tempBuffer[14]=0x01;
                                tempBuffer[16]=0x01;
                                tempBuffer[29]=0x65;
                                for(int b=0;b<32;b++)
                                {
                                        printByte(tempBuffer[b],1);
                                }
                                delay(10);
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPGGA") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
          case GPS_NMEA_GGA:    for(int c=0;c<32;c++)
                                {
                                        printByte(tempBuffer[c],1);
                                }
                                delay(10);
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPGGA") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
          case GPS_NMEA_GLL:    tempBuffer[6]=0x00;
                                tempBuffer[8]=0x01;
                                for(int d=0;d<32;d++)
                                {
                                        printByte(tempBuffer[d],1);
                                }
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPGLL") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
          case GPS_NMEA_GSA:    tempBuffer[6]=0x00;
                                tempBuffer[10]=0x01;
                                for(int e=0;e<32;e++)
                                {
                                        printByte(tempBuffer[e],1);
                                }
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPGSA") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
          case GPS_NMEA_GSV:    tempBuffer[6]=0x00;
                                tempBuffer[12]=0x01;
                                for(int f=0;f<32;f++)
                                {
                                        printByte(tempBuffer[f],1);
                                }
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPGSV") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
          case GPS_NMEA_RMC:    tempBuffer[6]=0x00;
                                tempBuffer[14]=0x01;
                                for(int g=0;g<32;g++)
                                {
                                        printByte(tempBuffer[g],1);
                                }
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPRMC") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
          case GPS_NMEA_VTG:    tempBuffer[6]=0x00;
                                tempBuffer[16]=0x01;
                                for(int h=0;h<32;h++)
                                {
                                        printByte(tempBuffer[h],1);
                                }
                                getRaw(100);
                                Utils.strExplode(Utils.inBuffer, ',');
                                if( strcmp(Utils.arguments[0],"$GPVTG") ) 
                                {
                                        valid=0;
                                }
                                else valid=1;
                                break;
  }
  return valid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t WaspGPS::getCommMode

(

void

)

It gets the communication mode on use.

Parameters:

void

Returns:

'commMode' variable that contains the communication mode on use

See also:

setCommMode()

Definition at line 452 of file WaspGPS.cpp.

References commMode.

{
  return commMode;
}

uint8_t WaspGPS::getPosition

(

)

It gets the latitude, longitude, altitude, speed, course, time and date.

Parameters:

void

Returns:

'1' if success, '0' if error

Definition at line 1135 of file WaspGPS.cpp.

References _uart, altitude, WaspUtils::arguments, commMode, course, dateGPS, delay(), flag, GPS_BINARY, GPS_BINARY_OFF, GPS_INVALID, GPS_NMEA, GPS_TIMEOUT, WaspUtils::inBuffer, latitude, longitude, MAX_ARGS, millis(), serialAvailable(), serialRead(), setCommMode(), speed, WaspUtils::strExplode(), timeGPS, and Utils.

{       
        flag &= ~(GPS_INVALID);
                
        uint16_t currentSentences = commMode;
        long previous=0;
        uint8_t complete = 0;
        
        uint8_t byteGPS = 0;            // the last byte coming through the port
        int i = 0;                      // count the amount of bytes read
        uint32_t timeout = 1000;        // millis to wait before declaring timeout
                
        // get all NMEA sentences
        while(!setCommMode(GPS_NMEA) && (millis()-previous)<3000);
        
        // separates all the subarrays from Utils.inBuffer into the Utils.arguments array         
        Utils.strExplode(Utils.inBuffer, ',');       
                
        
        previous = millis();
        while( complete<3 && (millis()-previous)<5000 )
        {
                if( !strcmp(Utils.arguments[0],"$GPGGA") ) 
                {
                        for(int i=0;i<MAX_ARGS;i++) timeGPS[i]=Utils.arguments[1][i];
                        for(int i=0;i<MAX_ARGS;i++) latitude[i]=Utils.arguments[2][i];
                        for(int i=0;i<MAX_ARGS;i++) longitude[i]=Utils.arguments[4][i];
                        for(int i=0;i<MAX_ARGS;i++) altitude[i]=Utils.arguments[9][i];  
                        complete++;
                }
                else if( !strcmp(Utils.arguments[0],"$GPRMC") )
                {
                        for(int i=0;i<MAX_ARGS;i++) dateGPS[i]=Utils.arguments[9][i];
                        for(int i=0;i<MAX_ARGS;i++) timeGPS[i]=Utils.arguments[1][i];
                        complete++;
                }
                else if( !strcmp(Utils.arguments[0],"$GPVTG") )
                {
                        for(int i=0;i<MAX_ARGS;i++) speed[i]=Utils.arguments[7][i];
                        for(int i=0;i<MAX_ARGS;i++) course[i]=Utils.arguments[1][i];
                        complete++;
                }
                
                while(!serialAvailable(_uart) && timeout > 0) { delay(1); timeout--; };         

                if (timeout <= 0)
                {
                        flag |= GPS_TIMEOUT;
                        return 1;
                }

                byteGPS = serialRead(_uart);    // read the first byte coming through the port         
                                
                while(byteGPS != '$')
                { 
                        if(serialAvailable(_uart) > 0){ 
                                byteGPS = serialRead(_uart); // flush incomplete sentences
                        }
                }
                Utils.inBuffer[i]=byteGPS;  
                i++;
                while(i <= 1 || (byteGPS != '*' && byteGPS != '$' && i < 100)){ // read the GPS sentence
                        if(serialAvailable(_uart) > 0)
                        {
                                byteGPS = serialRead(_uart);
                                if (byteGPS != '*' && byteGPS != '$' && i < 100) Utils.inBuffer[i]=byteGPS;
                                i++;
                        }  
                }
                
                if (byteGPS == '\n' || i == 100) Utils.inBuffer[i-1] = '\0';  
                else Utils.inBuffer[i] = '\0';
                
                i=0;
                
                Utils.strExplode(Utils.inBuffer, ',');       
        }
        
          // return to previous state
        previous=millis();
        if (currentSentences == GPS_BINARY_OFF ) while( !setCommMode(GPS_BINARY) && (millis()-previous)<3000);  
        delay(100);
        previous=millis();
        while(!setCommMode(currentSentences) && (millis()-previous)<3000);
                
        if( flag & GPS_INVALID ) return 0;
        else return 1;
}

Here is the call graph for this function:

---

Field Documentation

long WaspGPS::_baudRate

Variable : Baudrate used to init the UART and communicate with GPS receiver.

Possible values are 4800,9600,19200,38400,57600,115200.

4800 is the only value supported now by the API.

The reason is GPS receiver always starts at 4800bps, so it would be necessary to open UART at 4800, change speed, close UART and open it again at new speed.

If a higher speed wants to be used, previously explained reason has to be managed properly.

Definition at line 405 of file WaspGPS.h.

Referenced by begin(), setCommMode(), and WaspGPS().

uint8_t WaspGPS::_uart

Variable : UART used to communicate with GPS receiver.

Possible values are: 0 or 1.

UART used now to communicate with GPS is UART1, so '1' must be set.

Definition at line 413 of file WaspGPS.h.

Referenced by begin(), close(), getPosition(), getRaw(), loadEphems(), saveEphems(), setCommMode(), and WaspGPS().

bool WaspGPS::fixValid

Variable : Determines whether the last reading was valid or not.

TRUE if the last reading is valid.

FALSE if the last reading is not valid.

Definition at line 421 of file WaspGPS.h.

Referenced by dataValid(), getAltitude(), getLatitude(), and getLongitude().

uint16_t WaspGPS::flag

Variable : Flag used to determine if an error occurred while executing some function.

Possible values are related below.

See also:

ACK, GPS_TIMEOUT, GPS_ERROR_EPHEMERIS, GPS_ERROR_SAVE_EPHEMERIS, GPS_DATA_ERROR, GPS_BAD_SENTENCE, GPS_BAD_CHECKSUM, GPS_ERROR_FILE_EPHEMERIS, GPS_FILE_EPHEMERIS_EMPTY, GPS_ERROR_FILE_ALMANAC, GPS_FILE_ALMANAC_EMPTY, GPS_ERROR_SAVE_ALMANAC

Definition at line 431 of file WaspGPS.h.

Referenced by checkSum(), extractDate(), extractTime(), getAltitude(), getCourse(), getLatitude(), getLongitude(), getPosition(), getRaw(), getSpeed(), saveEphems(), and WaspGPS().

uint16_t WaspGPS::commMode

Variable : Communication mode. Two possibilities available --> binary mode or NMEA mode.

Possible values are related below.

See also:

GPS_BINARY, GPS_NMEA_GGA, GPS_NMEA_GLL, GPS_NMEA_GSA, GPS_NMEA_GSV, GPS_NMEA_RMC, GPS_NMEA_VTG, GPS_NMEA, GPS_BINARY_OFF

Definition at line 440 of file WaspGPS.h.

Referenced by check(), extractDate(), extractTime(), getAltitude(), getCommMode(), getCourse(), getLatitude(), getLongitude(), getPosition(), getSpeed(), setCommMode(), and WaspGPS().

uint8_t WaspGPS::pwrMode

Variable : Power mode used for GPS receiver.

Possible values are related below.

See also:

GPS_ON, GPS_OFF, GPS_SLEEP, GPS_HIBERNATE

Definition at line 448 of file WaspGPS.h.

Referenced by getMode(), setMode(), and WaspGPS().

uint8_t WaspGPS::wakeMode

Variable : Waking up mode used for GPS receiver.

Possible values are related below.

See also:

HOT, WARM, COLD

Definition at line 457 of file WaspGPS.h.

Referenced by WaspGPS().

char WaspGPS::timeGPS[MAX_ARGS]

Variable : Time extracted from NMEA GGA sentence received from GPS receiver.

String that contains the time extracted from NMEA GGA sentence.

To store the time 13:30:00, it is stored in this way: '133000'

Definition at line 465 of file WaspGPS.h.

Referenced by extractTime(), getPosition(), getTime(), and WaspRTC::setTimeFromGPS().

char WaspGPS::dateGPS[MAX_ARGS]

Variable : Date extracted from NMEA RMC sentence received from GPS receiver.

String that contains the date extracted from NMEA RMC sentence.

To store the date 23rd of March 1994, it is stored in this way: '230394'

Definition at line 473 of file WaspGPS.h.

Referenced by extractDate(), getDate(), getPosition(), and WaspRTC::setTimeFromGPS().

char* WaspGPS::clkOffset

Variable : Clock drift of the GPS receiver used to initialize it.

Value in Hz. Use '0' to use the last value saved, if not available 96250Hz will be used.

Definition at line 479 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::timeOfWeek

Variable : GPS Time of Week used to initialize it.

Time of week specified in seconds.

Definition at line 485 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::weekNo

Variable : Extended GPS Week Number used to initialize it.

Definition at line 490 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::channel

Variable : Channel Counter used to initialize it.

Definition at line 495 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::resetCfg

Variable : Reset Configuration.

Definition at line 500 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::coordinateLat

Variable : Default Latitude. + = North (Range 90 to -90). Expressed in degrees. Example-->37.3875111.

Definition at line 505 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::coordinateLon

Variable : Default Longitude. + = East (Range 180 to -180). Expressed in degrees. Example-->-121.97232.

Definition at line 510 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

char* WaspGPS::coordinateAl

Variable : Default Altitude position. Expressed in meters. Example-->0.

Definition at line 515 of file WaspGPS.h.

Referenced by init(), and WaspGPS().

uint8_t WaspGPS::checksum

Variable : the frame checksum.

Definition at line 520 of file WaspGPS.h.

Referenced by setChecksum(), and WaspGPS().

char WaspGPS::latitude[MAX_ARGS]

Variable : it stores the latitude given by the GPS module.

Definition at line 525 of file WaspGPS.h.

Referenced by getLatitude(), and getPosition().

char WaspGPS::longitude[MAX_ARGS]

Variable : it stores the longitude given by the GPS module.

Definition at line 530 of file WaspGPS.h.

Referenced by getLongitude(), and getPosition().

char WaspGPS::speed[MAX_ARGS]

Variable : it stores the speed given by the GPS module.

Definition at line 535 of file WaspGPS.h.

Referenced by getPosition(), and getSpeed().

char WaspGPS::altitude[MAX_ARGS]

Variable : it stores the altitude given by the GPS module.

Definition at line 540 of file WaspGPS.h.

Referenced by getAltitude(), and getPosition().

char WaspGPS::course[MAX_ARGS]

Variable : it stores the course given by the GPS module.

Definition at line 545 of file WaspGPS.h.

Referenced by getCourse(), and getPosition().

uint8_t WaspGPS::reboot

Variable : for rebooting the GPS module.

Definition at line 550 of file WaspGPS.h.

Referenced by close(), init(), and WaspGPS().

uint8_t WaspGPS::checkSUM[2]

Variable : for storing the frame checksum.

Definition at line 555 of file WaspGPS.h.

Referenced by getChecksum(), loadEphems(), and saveEphems().

---

The documentation for this class was generated from the following files:

• WaspGPS.h
• WaspGPS.cpp