nmea.cpp File Reference

Functions
static long	hex2int (const char *a, const int len)
static float	gps_deg_dec (float deg_point)
static void	gps_convert_deg_to_dec (float *latitude, char ns, float *longitude, char we)
static int	str_till_comma (const char *const a, char *const dStr)
static void	nmea_parse_gpgga (char const *const nmea, loc_t *loc)
static void	nmea_parse_gprmc (char const *const nmea, loc_t *loc)
nmea_message_type	nmea_get_message_type (const char *message)
int	nmea_valid_checksum (char const *message)
void	gps_location (loc_t *coord, char const *const buffer)

Function Documentation

gps_convert_deg_to_dec()

static void gps_convert_deg_to_dec ( float *  latitude, char  ns, float *  longitude, char  we  )

static

Definition at line 54 of file nmea.cpp.

                                                                                        {
    float lat = (ns == 'N') ? *latitude : -1 * (*latitude);
    float lon = (we == 'E') ? *longitude : -1 * (*longitude);
 
    *latitude = gps_deg_dec(lat);
    *longitude = gps_deg_dec(lon);
}

Referenced by gps_location().

Here is the call graph for this function:

Here is the caller graph for this function:

gps_deg_dec()

static float gps_deg_dec ( float  deg_point )

static

Definition at line 40 of file nmea.cpp.

                                          {
    float ddeg;
    float sec = modff(deg_point, &ddeg) * 60;
    int deg = (int) (ddeg / 100);
    int min = (int) (deg_point - (deg * 100));
 
    float absdlat = round(deg * 1000000.);
    float absmlat = round(min * 1000000.);
    float absslat = round(sec * 1000000.);
 
    return round(absdlat + (absmlat / 60) + (absslat / 3600)) / 1000000;
}

Referenced by gps_convert_deg_to_dec().

Here is the caller graph for this function:

gps_location()

void gps_location	(	loc_t *	coord,
		char const *const	buffer
	)

Definition at line 298 of file nmea.cpp.

                                                           {
    coord->type = nmea_get_message_type(buffer);
 
    switch (coord->type) {
    case NMEA_GPGGA:
        nmea_parse_gpgga(buffer, coord);
        gps_convert_deg_to_dec(&(coord->latitude), coord->lat, &(coord->longitude), coord->lon);
        break;
    case NMEA_GPRMC:
        nmea_parse_gprmc(buffer, coord);
        break;
    case NMEA_UNKNOWN:
        // unknown message type
        break;
    }
}

Referenced by onGpsMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

hex2int()

static long hex2int ( const char *  a, const int  len  )

static

Definition at line 28 of file nmea.cpp.

                                                   {
    int i;
    long val = 0;
 
    for (i = 0; i < len; i++)
        if (a[i] <= 57)
            val += (a[i] - 48) * (1 << (4 * (len - 1 - i))); // it's decimal number
        else
            val += (a[i] - 87) * (1 << (4 * (len - 1 - i))); // it's a-f -> work only with low case hex
    return val;
}

Referenced by nmea_valid_checksum().

Here is the caller graph for this function:

nmea_get_message_type()

nmea_message_type nmea_get_message_type

(

const char *

message

)

Get the message type (GPGGA, GPRMC, etc..)

This function filters out also wrong packages (invalid checksum)

Parameters

message

The NMEA message

Returns

The type of message if it is valid

Definition at line 259 of file nmea.cpp.

                                                             {
    int checksum = nmea_valid_checksum(message);
    if (checksum != _EMPTY) {
        return static_cast<nmea_message_type>(checksum);
    }
 
    if (strstr(message, NMEA_GPGGA_STR) != NULL) {
        return NMEA_GPGGA;
    }
 
    if (strstr(message, NMEA_GPRMC_STR) != NULL) {
        return NMEA_GPRMC;
    }
 
    return NMEA_UNKNOWN;
}

Referenced by gps_location().

Here is the call graph for this function:

Here is the caller graph for this function:

nmea_parse_gpgga()

static void nmea_parse_gpgga ( char const *const  nmea, loc_t *  loc  )

static

Definition at line 95 of file nmea.cpp.

                                                                  {
    char const * p = (char *)nmea;
    char dStr[GPS_MAX_STRING];
 
    p = strchr(p, ',') + 1;                 //skip time - we read date&time if Valid in GxRMC
 
    p = strchr(p, ',') + 1;                 // in p string started with searching address
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    if (strlen(p) == 0) {
        return;             // if no data in field - empty data - we return
    }
    
    loc->latitude = atoff(dStr);                // fulfil data
 
    p = strchr(p, ',') + 1;                 // see above
    switch (p[0]) {
    case 'N':
        loc->lat = 'N';
        break;
    case 'S':
        loc->lat = 'S';
        break;
    case ',':
        loc->lat = '\0';
        break;
    }
 
    p = strchr(p, ',') + 1;
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->longitude = atoff(dStr);
 
    p = strchr(p, ',') + 1;
    switch (p[0]) {
    case 'W':
        loc->lon = 'W';
        break;
    case 'E':
        loc->lon = 'E';
        break;
    case ',':
        loc->lon = '\0';
        break;
    }
 
    p = strchr(p, ',') + 1;
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->quality = atoi(dStr);
 
    p = strchr(p, ',') + 1;
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->satellites = atoi(dStr);
 
    p = strchr(p, ',') + 1;
 
    p = strchr(p, ',') + 1;
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->altitude = atoff(dStr);
}

Referenced by gps_location().

Here is the call graph for this function:

Here is the caller graph for this function:

nmea_parse_gprmc()

static void nmea_parse_gprmc ( char const *const  nmea, loc_t *  loc  )

static

Definition at line 172 of file nmea.cpp.

                                                                  {
    char const * p = (char *)nmea;
    char dStr[GPS_MAX_STRING];
    efidatetime_t dt;
 
    p = strchr(p, ',') + 1;                 // read time
    str_till_comma(p, dStr);
    if (strlen(dStr) > 5) {
        dt.hour = str2int(dStr, 2);
        dt.minute = str2int(dStr + 2, 2);
        dt.second = str2int(dStr + 4, 2);
    }
    
    p = strchr(p, ',') + 1;                 // read field Valid status
    str_till_comma(p, dStr);
 
    if (dStr[0] == 'V') {                   // if field is invalid
        loc->quality = 0;
        return;
    }
    
    loc->quality = 4;                       // this is declaration that last receive field VALID
    
    p = strchr(p, ',') + 1;                 // latitude
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->latitude = atoff(dStr);
 
    p = strchr(p, ',') + 1;
    switch (p[0]) {
    case 'N':
        loc->lat = 'N';
        break;
    case 'S':
        loc->lat = 'S';
        break;
    case ',':
        loc->lat = '\0';
        break;
    }
 
    p = strchr(p, ',') + 1;                 // longitude
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->longitude = atoff(dStr);
 
    p = strchr(p, ',') + 1;
    switch (p[0]) {
    case 'W':
        loc->lon = 'W';
        break;
    case 'E':
        loc->lon = 'E';
        break;
    case ',':
        loc->lon = '\0';
        break;
    }
 
    p = strchr(p, ',') + 1;
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->speed = atoff(dStr);
    
    p = strchr(p, ',') + 1;
    str_till_comma(p, dStr);                // str to float till comma saved modified string
    loc->course = atoff(dStr);
 
    p = strchr(p, ',') + 1;                 // read date
    str_till_comma(p, dStr);
    if (strlen(dStr) > 5) {
        dt.day = str2int(dStr, 2);
        dt.month = str2int(dStr + 2, 2);
        dt.year = 100 +                     // we receive -200, but standard wait -1900 = add correction
            str2int(dStr + 4, 2);
    }
 
    if (dt.year > 0 ) {                     // check if date field is valid
        memcpy(&loc->time, &dt, sizeof(dt));
    }
}

Referenced by gps_location().

Here is the call graph for this function:

Here is the caller graph for this function:

nmea_valid_checksum()

int nmea_valid_checksum

(

char const *

message

)

Definition at line 276 of file nmea.cpp.

                                              {
    char p;
    int sum = 0;
    const char* starPtr = strrchr(message, '*');
    if (!starPtr) {
        return NMEA_CHECKSUM_ERR;
    }
    const char* int_message = starPtr + 1;
    long checksum = hex2int(int_message, 2);
 
    ++message;
    while ((p = *message++) != '*') {
        sum ^= p;
    }
 
    if (sum != checksum) {
        return NMEA_CHECKSUM_ERR;
    }
    return _EMPTY;
}

Referenced by nmea_get_message_type().

Here is the call graph for this function:

Here is the caller graph for this function:

str_till_comma()

static int str_till_comma ( const char *const  a, char *const  dStr  )

static

Definition at line 63 of file nmea.cpp.

                                                                   {
 
    int i = 0, sLen = strlen(a);
    if (sLen > GPS_MAX_STRING)
        sLen = GPS_MAX_STRING;
 
    while (i < sLen && a[i] != 44) {    // while not comma or end
        dStr[i] = a[i];
        i++;
    }
    dStr[i] = '\0';
    return i;
}

Referenced by nmea_parse_gpgga(), and nmea_parse_gprmc().

Here is the caller graph for this function:

Go to the source code of this file.