NEO-6 Internal Helpers

Functions
static ERR_te	neo6_calc_checksum (char *msg, uint32_t msg_len, uint8_t *checksum_o)
	Computes the NMEA checksum of a sentence by XORing all bytes between '$' and '*'.
static ERR_te	neo6_process_msg (uint8_t *msg, uint32_t msg_len)
	Verifies the checksum of a received NMEA sentence and dispatches it to the appropriate parser.
static ERR_te	neo6_process_rmc (char **tokens)
	Parses an RMC sentence and updates time, date, latitude, and longitude.
static ERR_te	neo6_process_vtg (char **tokens)
	Parses a VTG sentence and updates movement direction and speed.
static ERR_te	neo6_process_gga (char **tokens)
	Parses a GGA sentence and updates fix status, satellites used, orthometric height, and geoid separation.
static ERR_te	neo6_process_gsa (char **tokens)
	Parses a GSA sentence and updates fix type, PDOP, HDOP, and VDOP.
static ERR_te	neo6_process_gsv (char **tokens)
	Parses a GSV sentence and updates the total satellite count.

Detailed Description

Function Documentation

neo6_calc_checksum()

ERR_te neo6_calc_checksum ( char * msg, uint32_t msg_len, uint8_t * checksum_o )

static

Computes the NMEA checksum of a sentence by XORing all bytes between '$' and '*'.

Iterates through msg, skipping the leading '$', XORing each byte until '*' is encountered. The result is the standard NMEA XOR checksum.

Parameters

[in]	msg	Pointer to the null-terminated NMEA sentence string.
[in]	msg_len	Length of the message in bytes.
[out]	checksum_o	Pointer to a variable that will receive the computed checksum.

Returns

• ERR_OK on success
• ERR_UNKNOWN if '*' is not found before msg_len bytes are consumed

Definition at line 458 of file neo6.c.

                                                                                   {
    uint8_t xor_val = 0;
    uint32_t char_count = 0;
 
    while(*msg != '*' && char_count < msg_len) {
        if(*msg == '$') {
            msg++;
            continue;
        }
 
        xor_val ^= *msg;
 
        msg++;
        char_count++;
 
        if(char_count == msg_len) {
            return ERR_UNKNOWN;
        }
    }
    *checksum_o = xor_val;
 
    return ERR_OK;
}

Here is the caller graph for this function:

neo6_process_msg()

ERR_te neo6_process_msg ( uint8_t * msg, uint32_t msg_len )

static

Verifies the checksum of a received NMEA sentence and dispatches it to the appropriate parser.

Extracts the two-character hex checksum from the end of the sentence, computes the expected checksum via neo6_calc_checksum, and compares them. On a match, tokenizes the sentence by comma and dispatches to neo6_process_rmc, neo6_process_vtg, neo6_process_gga, neo6_process_gsa, or neo6_process_gsv based on the sentence ID. Unrecognized sentence types are silently ignored.

Parameters

[in]	msg	Pointer to the raw NMEA sentence bytes.
[in]	msg_len	Length of the sentence in bytes.

Returns

• ERR_OK on success or for unrecognized sentence types
• ERR_DATA_ACQUISITION_FAILURE if the checksum does not match
• Propagated error from neo6_calc_checksum on failure

Definition at line 501 of file neo6.c.

                                                               {
    ERR_te err;
 
    uint8_t checksum_recv = ascii_hex_to_byte(msg[msg_len - 4], msg[msg_len - 3]);
 
    uint8_t checksum_calc = 0;
    err = neo6_calc_checksum((char*)msg, msg_len, &checksum_calc);
    if(err != ERR_OK) {
        return err;
    }
 
    char *tokens[CONFIG_NEO6_MAX_TOKENS];
    uint16_t num_tokens = 0;
 
    if(checksum_recv == checksum_calc) {
        str_tokenize((char*)msg, ",", CONFIG_NEO6_MAX_TOKENS, tokens, &num_tokens);
 
        if(str_cmp("$GPRMC", tokens[0]) == true) {
            neo6_process_rmc(tokens);
        }
        else if(str_cmp("$GPVTG", tokens[0]) == true) {
            neo6_process_vtg(tokens);
        }
        else if(str_cmp("$GPGGA", tokens[0]) == true) {
            neo6_process_gga(tokens);
        }
        else if(str_cmp("$GPGSA", tokens[0]) == true) {
            neo6_process_gsa(tokens);
        }
        else if(str_cmp("$GPGSV", tokens[0]) == true) {
            neo6_process_gsv(tokens);
        }
    }
    else {
        return ERR_DATA_ACQUISITION_FAILURE;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_process_rmc()

ERR_te neo6_process_rmc ( char ** tokens )

static

Parses an RMC sentence and updates time, date, latitude, and longitude.

If the validity flag (token 2) is not "A" (active), all four fields are set to "No data" and the function returns early. Otherwise: time is formatted as "HH:MM:SS UTC", date as "DD/MM/YYYY", and latitude/longitude have their hemisphere indicator appended.

Parameters

[in]

tokens

Tokenized RMC sentence (comma-separated fields).

Returns

• ERR_OK on success
• ERR_UNKNOWN if the validity flag is not "A"

Definition at line 556 of file neo6.c.

                                              {
    if(str_cmp(tokens[2], "A") == false) {
        str_cpy(internal_state.neo6_info.time, "No data",
            get_str_len("No data") + 1);
 
        str_cpy(internal_state.neo6_info.date, "No data",
            get_str_len("No data") + 1);
 
        str_cpy(internal_state.neo6_info.lon, "No data",
            get_str_len("No data") + 1);
 
        str_cpy(internal_state.neo6_info.lat, "No data",
            get_str_len("No data") + 1);
 
        return ERR_UNKNOWN;
    }
 
    // UTC — format hhmmss → HH:MM:SS UTC
    uint8_t time_len = 6;
    int8_t real_counter = 0;
    for(uint8_t j = 0; j < time_len; j++) {
        internal_state.neo6_info.time[real_counter++] = tokens[1][j];
 
        if((real_counter + 1) % 3 == 0 && real_counter <= 5) {
            internal_state.neo6_info.time[real_counter++] = ':';
        }
    }
    internal_state.neo6_info.time[real_counter++] = ' ';
    internal_state.neo6_info.time[real_counter++] = 'U';
    internal_state.neo6_info.time[real_counter++] = 'T';
    internal_state.neo6_info.time[real_counter++] = 'C';
    internal_state.neo6_info.time[real_counter++] = '\0';
 
    // Latitude
    uint8_t lat_txt_len = get_str_len(tokens[3]);
    for(uint8_t j = 0; j < lat_txt_len; j++) {
        internal_state.neo6_info.lat[j] = tokens[3][j];
    }
    internal_state.neo6_info.lat[lat_txt_len] = tokens[4][0];
    internal_state.neo6_info.lat[lat_txt_len + 1] = '\0';
 
    // Longitude
    uint8_t lon_txt_len = get_str_len(tokens[5]);
    for(uint8_t j = 0; j < lon_txt_len; j++) {
        internal_state.neo6_info.lon[j] = tokens[5][j];
    }
    internal_state.neo6_info.lon[lon_txt_len] = tokens[6][0];
    internal_state.neo6_info.lon[lon_txt_len + 1] = '\0';
 
    // Date — format ddmmyy → DD/MM/20YY
    internal_state.neo6_info.date[0] = tokens[9][0];
    internal_state.neo6_info.date[1] = tokens[9][1];
    internal_state.neo6_info.date[2] = '/';
    internal_state.neo6_info.date[3] = tokens[9][2];
    internal_state.neo6_info.date[4] = tokens[9][3];
    internal_state.neo6_info.date[5] = '/';
    internal_state.neo6_info.date[6] = '2';
    internal_state.neo6_info.date[7] = '0';
    internal_state.neo6_info.date[8] = tokens[9][4];
    internal_state.neo6_info.date[9] = tokens[9][5];
    internal_state.neo6_info.date[10] = '\0';
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_process_vtg()

ERR_te neo6_process_vtg ( char ** tokens )

static

Parses a VTG sentence and updates movement direction and speed.

Direction is taken from the true-north track field. Speed is taken from the speed-over-ground field and has " kph" appended. Empty fields result in "No data" being written instead.

Parameters

[in]

tokens

Tokenized VTG sentence.

Returns

• ERR_OK always

Definition at line 634 of file neo6.c.

                                              {
    // Movement direction (relative to true north)
    uint8_t track_made_good_len = get_str_len(tokens[VTG_TMG_T_DEGREE_POS]);
    if(track_made_good_len == 0) {
        str_cpy(internal_state.neo6_info.mov_dir, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.mov_dir, &tokens[VTG_TMG_T_DEGREE_POS][0],
            track_made_good_len + 1);
    }
 
    // Movement speed (kph)
    uint8_t kph_len = get_str_len(tokens[VTG_SPEED_OVER_GROUND_POS]);
    if(kph_len == 0) {
        str_cpy(internal_state.neo6_info.mov_speed, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.mov_speed, &tokens[VTG_SPEED_OVER_GROUND_POS][0],
            kph_len + 1);
        internal_state.neo6_info.mov_speed[kph_len++] = ' ';
        internal_state.neo6_info.mov_speed[kph_len++] = 'k';
        internal_state.neo6_info.mov_speed[kph_len++] = 'p';
        internal_state.neo6_info.mov_speed[kph_len++] = 'h';
        internal_state.neo6_info.mov_speed[kph_len++] = '\0';
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_process_gga()

ERR_te neo6_process_gga ( char ** tokens )

static

Parses a GGA sentence and updates fix status, satellites used, orthometric height, and geoid separation.

Fix quality is mapped to a human-readable string: "No valid fix" (0), "GPS fix" (1), "DGPS fix" (2). Height and separation values have their unit character appended. Empty fields result in "No data".

Parameters

[in]

tokens

Tokenized GGA sentence.

Returns

• ERR_OK always

Definition at line 678 of file neo6.c.

                                              {
    // Quality of the fix
    uint8_t fix_status_len = get_str_len(tokens[GGA_QUALITY_FIX_POS]);
    if(fix_status_len == 0) {
        str_cpy(internal_state.neo6_info.fix_status, "No data",
            get_str_len("No data") + 1);
    }
    else if(str_cmp(tokens[GGA_QUALITY_FIX_POS], "0") == true) {
        char msg[] = "No valid fix";
        str_cpy(internal_state.neo6_info.fix_status, msg, get_str_len(msg) + 1);
    }
    else if(str_cmp(tokens[GGA_QUALITY_FIX_POS], "1") == true) {
        char msg[] = "GPS fix";
        str_cpy(internal_state.neo6_info.fix_status, msg, get_str_len(msg) + 1);
    }
    else if(str_cmp(tokens[GGA_QUALITY_FIX_POS], "2") == true) {
        char msg[] = "DGPS fix";
        str_cpy(internal_state.neo6_info.fix_status, msg, get_str_len(msg) + 1);
    }
    else {
        char msg[] = "?";
        str_cpy(internal_state.neo6_info.fix_status, msg, get_str_len(msg) + 1);
    }
 
    // Number of satellites used
    uint8_t num_sats_used_len = get_str_len(tokens[GGA_NUM_SATS_POS]);
    if(num_sats_used_len == 0) {
        str_cpy(internal_state.neo6_info.num_sats_used, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.num_sats_used, tokens[GGA_NUM_SATS_POS],
            get_str_len(tokens[GGA_NUM_SATS_POS]) + 1);
    }
 
    // Orthometric height
    uint8_t ort_height_len = get_str_len(tokens[GGA_ORTH_HEIGHT_POS]);
    if(ort_height_len == 0) {
        str_cpy(internal_state.neo6_info.ort_height, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.ort_height, tokens[GGA_ORTH_HEIGHT_POS],
            ort_height_len + 1);
        internal_state.neo6_info.ort_height[ort_height_len] = ' ';
        internal_state.neo6_info.ort_height[ort_height_len + 1] = tokens[GGA_ORTH_HEIGHT_UNIT_POS][0];
        internal_state.neo6_info.ort_height[ort_height_len + 2] = '\0';
    }
 
    // Geoid separation
    uint8_t geoid_sep_len = get_str_len(tokens[GGA_GEOID_SEP_POS]);
    if(geoid_sep_len == 0) {
        str_cpy(internal_state.neo6_info.geoid_sep, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.geoid_sep, tokens[GGA_GEOID_SEP_POS],
            geoid_sep_len + 1);
        internal_state.neo6_info.geoid_sep[geoid_sep_len] = ' ';
        internal_state.neo6_info.geoid_sep[geoid_sep_len + 1] = tokens[GGA_GEOID_SEP_UNIT_POS][0];
        internal_state.neo6_info.geoid_sep[geoid_sep_len + 2] = '\0';
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_process_gsa()

ERR_te neo6_process_gsa ( char ** tokens )

static

Parses a GSA sentence and updates fix type, PDOP, HDOP, and VDOP.

Fix type is mapped to a human-readable string: "Not available" (1), "2D" (2), "3D" (3). VDOP strips the trailing NMEA checksum suffix (*XX) before storing. Empty fields result in "No data".

Parameters

[in]

tokens

Tokenized GSA sentence.

Returns

• ERR_OK always

Definition at line 757 of file neo6.c.

                                              {
    uint8_t msg_part_len = get_str_len(tokens[GSA_FIX_TYPE_POS]);
    if(msg_part_len == 0) {
        str_cpy(internal_state.neo6_info.fix_type, "No data",
            get_str_len("No data") + 1);
    }
    else {
        if(str_cmp(tokens[GSA_FIX_TYPE_POS], "1") == true) {
            str_cpy(internal_state.neo6_info.fix_type, "Not available",
                get_str_len("Not available") + 1);
        }
        else if(str_cmp(tokens[GSA_FIX_TYPE_POS], "2") == true) {
            str_cpy(internal_state.neo6_info.fix_type, "2D",
                get_str_len("2D") + 1);
        }
        else if(str_cmp(tokens[GSA_FIX_TYPE_POS], "3") == true) {
            str_cpy(internal_state.neo6_info.fix_type, "3D",
                get_str_len("3D") + 1);
        }
    }
 
    msg_part_len = get_str_len(tokens[GSA_PDOP_POS]);
    if(msg_part_len == 0) {
        str_cpy(internal_state.neo6_info.pdop, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.pdop, tokens[GSA_PDOP_POS],
            msg_part_len + 1);
    }
 
    msg_part_len = get_str_len(tokens[GSA_HDOP_POS]);
    if(msg_part_len == 0) {
        str_cpy(internal_state.neo6_info.hdop, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.hdop, tokens[GSA_HDOP_POS],
            msg_part_len + 1);
    }
 
    // VDOP: subtract 2 to strip the trailing checksum suffix (*XX)
    msg_part_len = get_str_len(tokens[GSA_VDOP_POS]) - 2;
    if(msg_part_len == 0) {
        str_cpy(internal_state.neo6_info.vdop, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.vdop, tokens[GSA_VDOP_POS],
            msg_part_len);
        internal_state.neo6_info.vdop[msg_part_len] = '\0';
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_process_gsv()

ERR_te neo6_process_gsv ( char ** tokens )

static

Parses a GSV sentence and updates the total satellite count.

Only the total number of satellites in view is extracted. The per-satellite detail fields (PRN, elevation, azimuth, SNR) are not currently stored. Empty fields result in "No data".

Parameters

[in]

tokens

Tokenized GSV sentence.

Returns

• ERR_OK always

Definition at line 826 of file neo6.c.

                                              {
    uint8_t msg_part_len = get_str_len(tokens[GSV_NUM_SATS_VISIBLE_POS]);
    if(msg_part_len == 0) {
        str_cpy(internal_state.neo6_info.num_sats_all, "No data",
            get_str_len("No data") + 1);
    }
    else {
        str_cpy(internal_state.neo6_info.num_sats_all, tokens[GSV_NUM_SATS_VISIBLE_POS],
            msg_part_len + 1);
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: