merge with master

Makefile

@@ -4,8 +4,8 @@
 # the terms of the Do What The Fuck You Want To Public License, Version 2, as
 # published by Sam Hocevar. See the COPYING file for more details.
 
-CFLAGS = -g -Wall -Wextra -Werror
-LDFLAGS = -lcheck
+CFLAGS = -g -Wall -Wextra -Werror -std=c99
+LDLIBS = -lcheck
 
 all: scan-build test example
 	@echo "+++ All good."""

README.md

@@ -20,27 +20,33 @@ systems.
 * ``GGA`` (Fix Data)
 * ``GSA`` (DOP and active satellites)
 * ``GLL`` (Geographic Position -- Latitude/Longitude)
+* ``GST`` (Pseudorange Noise Statistics)
+* ``GSV`` (Satellites in view)
 
 Adding support for more sentences is trivial; see ``minmea.c`` source.
 
 ## Fractional number format
 
-Internally, minmea stores fractional numbers as pairs of two integers: ``(value, scale)``.
-For example, a value of ``"-123.456"`` would be parsed as ``(-123456, 1000)``. As this
-format is quite unwieldy, minmea provides the following convenience macros for converting
+Internally, minmea stores fractional numbers as pairs of two integers: ``{value, scale}``.
+For example, a value of ``"-123.456"`` would be parsed as ``{-123456, 1000}``. As this
+format is quite unwieldy, minmea provides the following convenience functions for converting
 to either fixed-point or floating-point format:
 
-* ``minmea_rescale(-123456, 1000, 10) => -1235``
-* ``minmea_float(-123456, 1000) => -123.456``
+* ``minmea_rescale({-123456, 1000}, 10) => -1235``
+* ``minmea_float({-123456, 1000}) => -123.456``
+
+The compound type ``struct minmea_float`` uses ``int_least32_t`` internally. Therefore,
+the coordinate precision is guaranteed to be at least ``[+-]DDDMM.MMMMM`` (five decimal digits)
+or ±20cm LSB at the equator.
 
 ## Coordinate format
 
 NMEA uses the clunky ``DDMM.MMMM`` format which, honestly, is not good in the internet era.
 Internally, minmea stores it as a fractional number (see above); for practical uses,
 the value should be probably converted to the DD.DDDDD floating point format using the
-following macro:
+following function:
 
-* ``minmea_coord(-375165, 100) => -37.860832``
+* ``minmea_tocoord({-375165, 100}) => -37.860832``
 
 The library doesn't perform this conversion automatically for the following reasons:
 
@@ -51,36 +57,49 @@ The library doesn't perform this conversion automatically for the following reas
 ## Example
 
 ```c
-    char line[MINMEA_MAX_LENGTH];
-    while (fgets(line, sizeof(line), stdin) != NULL) {
-        printf("%s", line);
-        switch (minmea_sentence_id(line)) {
-            case MINMEA_SENTENCE_RMC: {
-                struct minmea_sentence_rmc frame;
-                if (minmea_parse_rmc(&frame, line)) {
-                    printf("+++ raw coordinates and speed: (%d/%d,%d/%d) %d/%d\n",
-                            frame.latitude, frame.latitude_scale,
-                            frame.longitude, frame.longitude_scale,
-                            frame.speed, frame.speed_scale);
-                    printf("+++ fixed-point coordinates and speed scaled to three decimal places: (%d,%d) %d\n",
-                            minmea_rescale(frame.latitude, frame.latitude_scale, 1000),
-                            minmea_rescale(frame.longitude, frame.longitude_scale, 1000),
-                            minmea_rescale(frame.speed, frame.speed_scale, 1000));
-                    printf("+++ floating point degree coordinates and speed: (%f,%f) %f\n",
-                            minmea_coord(frame.latitude, frame.latitude_scale),
-                            minmea_coord(frame.longitude, frame.longitude_scale),
-                            minmea_float(frame.speed, frame.speed_scale));
-                }
-            } break;
-
-            case MINMEA_SENTENCE_GGA: {
-                struct minmea_sentence_gga frame;
-                if (minmea_parse_gga(&frame, line)) {
-                    printf("$GPGGA: fix quality: %d\n", frame.fix_quality);
-                }
-            } break;
-        }
+char line[MINMEA_MAX_LENGTH];
+while (fgets(line, sizeof(line), stdin) != NULL) {
+    switch (minmea_sentence_id(line)) {
+        case MINMEA_SENTENCE_RMC: {
+            struct minmea_sentence_rmc frame;
+            if (minmea_parse_rmc(&frame, line)) {
+                printf("$RMC: raw coordinates and speed: (%d/%d,%d/%d) %d/%d\n",
+                        frame.latitude.value, frame.latitude.scale,
+                        frame.longitude.value, frame.longitude.scale,
+                        frame.speed.value, frame.speed.scale);
+                printf("$RMC fixed-point coordinates and speed scaled to three decimal places: (%d,%d) %d\n",
+                        minmea_rescale(&frame.latitude, 1000),
+                        minmea_rescale(&frame.longitude, 1000),
+                        minmea_rescale(&frame.speed, 1000));
+                printf("$RMC floating point degree coordinates and speed: (%f,%f) %f\n",
+                        minmea_tocoord(&frame.latitude),
+                        minmea_tocoord(&frame.longitude),
+                        minmea_tofloat(&frame.speed));
+            }
+        } break;
+
+        case MINMEA_SENTENCE_GGA: {
+            struct minmea_sentence_gga frame;
+            if (minmea_parse_gga(&frame, line)) {
+                printf("$GGA: fix quality: %d\n", frame.fix_quality);
+            }
+        } break;
+
+        case MINMEA_SENTENCE_GSV: {
+            struct minmea_sentence_gsv frame;
+            if (minmea_parse_gsv(&frame, line)) {
+                printf("$GSV: message %d of %d\n", frame.msg_nr, frame.total_msgs);
+                printf("$GSV: sattelites in view: %d\n", frame.total_sats);
+                for (int i = 0; i < 4; i++)
+                    printf("$GSV: sat nr %d, elevation: %d, azimuth: %d, snr: %d dbm\n",
+                        frame.sats[i].nr,
+                        frame.sats[i].elevation,
+                        frame.sats[i].azimuth,
+                        frame.sats[i].snr);
+            }
+        } break;
     }
+}
 ```
 
 ## Integration with your project
@@ -100,10 +119,6 @@ typing ``make``.
 
 ## Limitations
 
-* Fractional numbers are represented as ``int`` internally, which is 32 bits on
-  most embedded platforms. Therefore, the maximum supported coordinate precision
-  is ``[+-]DDDMM.MMMMM``. The library does not check for integer overflow at the
-  moment; coordinates with more precision will not parse correctly.
 * Only a handful of frames is supported right now.
 * There's no support for omitting parts of the library from building. As
   a workaround, use the ``-ffunction-sections -Wl,--gc-sections`` linker flags

example.c

@@ -21,25 +21,58 @@ int main()
             case MINMEA_SENTENCE_RMC: {
                 struct minmea_sentence_rmc frame;
                 if (minmea_parse_rmc(&frame, line)) {
-                    printf("+++ raw coordinates and speed: (%d/%d,%d/%d) %d/%d\n",
-                            frame.latitude, frame.latitude_scale,
-                            frame.longitude, frame.longitude_scale,
-                            frame.speed, frame.speed_scale);
-                    printf("+++ fixed-point coordinates and speed scaled to three decimal places: (%d,%d) %d\n",
-                            minmea_rescale(frame.latitude, frame.latitude_scale, 1000),
-                            minmea_rescale(frame.longitude, frame.longitude_scale, 1000),
-                            minmea_rescale(frame.speed, frame.speed_scale, 1000));
-                    printf("+++ floating point degree coordinates and speed: (%f,%f) %f\n",
-                            minmea_coord(frame.latitude, frame.latitude_scale),
-                            minmea_coord(frame.longitude, frame.longitude_scale),
-                            minmea_float(frame.speed, frame.speed_scale));
+                    printf("$xxRMC: raw coordinates and speed: (%d/%d,%d/%d) %d/%d\n",
+                            frame.latitude.value, frame.latitude.scale,
+                            frame.longitude.value, frame.longitude.scale,
+                            frame.speed.value, frame.speed.scale);
+                    printf("$xxRMC fixed-point coordinates and speed scaled to three decimal places: (%d,%d) %d\n",
+                            minmea_rescale(&frame.latitude, 1000),
+                            minmea_rescale(&frame.longitude, 1000),
+                            minmea_rescale(&frame.speed, 1000));
+                    printf("$xxRMC floating point degree coordinates and speed: (%f,%f) %f\n",
+                            minmea_tocoord(&frame.latitude),
+                            minmea_tocoord(&frame.longitude),
+                            minmea_tofloat(&frame.speed));
                 }
             } break;
 
             case MINMEA_SENTENCE_GGA: {
                 struct minmea_sentence_gga frame;
                 if (minmea_parse_gga(&frame, line)) {
-                    printf("$GPGGA: fix quality: %d\n", frame.fix_quality);
+                    printf("$xxGGA: fix quality: %d\n", frame.fix_quality);
+                }
+            } break;
+
+            case MINMEA_SENTENCE_GST: {
+                struct minmea_sentence_gst frame;
+                if (minmea_parse_gst(&frame, line)) {
+                    printf("$xxGST: raw latitude,longitude and altitude error deviation: (%d/%d,%d/%d,%d/%d)\n",
+                            frame.latitude_error_deviation.value, frame.latitude_error_deviation.scale,
+                            frame.longitude_error_deviation.value, frame.longitude_error_deviation.scale,
+                            frame.altitude_error_deviation.value, frame.altitude_error_deviation.scale);
+                    printf("$xxGST fixed point latitude,longitude and altitude error deviation \
+                           scaled to one decimal place: (%d,%d,%d)\n",
+                            minmea_rescale(&frame.latitude_error_deviation, 10),
+                            minmea_rescale(&frame.longitude_error_deviation, 10),
+                            minmea_rescale(&frame.altitude_error_deviation, 10));
+                    printf("$xxGST floating point degree latitude, longitude and altitude error deviation: (%f,%f,%f)",
+                            minmea_tofloat(&frame.latitude_error_deviation),
+                            minmea_tofloat(&frame.longitude_error_deviation),
+                            minmea_tofloat(&frame.altitude_error_deviation));
+                }
+            } break;
+
+            case MINMEA_SENTENCE_GSV: {
+                struct minmea_sentence_gsv frame;
+                if (minmea_parse_gsv(&frame, line)) {
+                    printf("$xxGSV: message %d of %d\n", frame.msg_nr, frame.total_msgs);
+                    printf("$xxGSV: sattelites in view: %d\n", frame.total_sats);
+                    for (int i = 0; i < 4; i++)
+                        printf("$xxGSV: sat nr %d, elevation: %d, azimuth: %d, snr: %d dbm\n",
+                            frame.sats[i].nr,
+                            frame.sats[i].elevation,
+                            frame.sats[i].azimuth,
+                            frame.sats[i].snr);
                 }
             } break;
 

minmea.c

@@ -72,27 +72,45 @@ static inline bool minmea_isfield(char c) {
 bool minmea_scan(const char *sentence, const char *format, ...)
 {
     bool result = false;
+    bool optional = false;
     va_list ap;
     va_start(ap, format);
 
     const char *field = sentence;
 #define next_field() \
     do { \
-        while (minmea_isfield(*sentence++)) {} \
-        field = sentence; \
+        /* Progress to the next field. */ \
+        while (minmea_isfield(*sentence)) \
+            sentence++; \
+        /* Make sure there is a field there. */ \
+        if (*sentence == ',') { \
+            sentence++; \
+            field = sentence; \
+        } else { \
+            field = NULL; \
+        } \
     } while (0)
 
     while (*format) {
         char type = *format++;
 
+        if (type == ';') {
+            // All further fields are optional.
+            optional = true;
+            continue;
+        }
+
+        if (!field && !optional) {
+            // Field requested but we ran out if input. Bail out.
+            goto parse_error;
+        }
+
         switch (type) {
             case 'c': { // Single character field (char).
                 char value = '\0';
 
-                if (minmea_isfield(*field))
+                if (field && minmea_isfield(*field))
                     value = *field;
-                else
-                    value = '\0';
 
                 *va_arg(ap, char *) = value;
             } break;
@@ -100,7 +118,7 @@ bool minmea_scan(const char *sentence, const char *format, ...)
             case 'd': { // Single character direction field (int).
                 int value = 0;
 
-                if (minmea_isfield(*field)) {
+                if (field && minmea_isfield(*field)) {
                     switch (*field) {
                         case 'N':
                         case 'E':
@@ -111,58 +129,76 @@ bool minmea_scan(const char *sentence, const char *format, ...)
                             value = -1;
                             break;
                         default:
-                            goto end;
+                            goto parse_error;
                     }
                 }
 
                 *va_arg(ap, int *) = value;
             } break;
 
-            case 'f': { // Fractional value with scale (int, int).
+            case 'f': { // Fractional value with scale (struct minmea_float).
                 int sign = 0;
-                int value = -1;
-                int scale = 0;
-
-                while (minmea_isfield(*field)) {
-                    if (*field == '+' && !sign && value == -1) {
-                        sign = 1;
-                    } else if (*field == '-' && !sign && value == -1) {
-                        sign = -1;
-                    } else if (isdigit((unsigned char) *field)) {
-                        if (value == -1)
-                            value = 0;
-                        value = (10 * value) + (*field - '0');
-                        if (scale)
-                            scale *= 10;
-                    } else if (*field == '.' && scale == 0) {
-                        scale = 1;
-                    } else {
-                        goto end;
+                int_least32_t value = -1;
+                int_least32_t scale = 0;
+
+                if (field) {
+                    while (minmea_isfield(*field)) {
+                        if (*field == '+' && !sign && value == -1) {
+                            sign = 1;
+                        } else if (*field == '-' && !sign && value == -1) {
+                            sign = -1;
+                        } else if (isdigit((unsigned char) *field)) {
+                            int digit = *field - '0';
+                            if (value == -1)
+                                value = 0;
+                            if (value > (INT_LEAST32_MAX-digit) / 10) {
+                                /* we ran out of bits, what do we do? */
+                                if (scale) {
+                                    /* truncate extra precision */
+                                    break;
+                                } else {
+                                    /* integer overflow. bail out. */
+                                    goto parse_error;
+                                }
+                            }
+                            value = (10 * value) + digit;
+                            if (scale)
+                                scale *= 10;
+                        } else if (*field == '.' && scale == 0) {
+                            scale = 1;
+                        } else {
+                            goto parse_error;
+                        }
+                        field++;
                     }
-                    field++;
                 }
 
                 if ((sign || scale) && value == -1)
-                    goto end;
+                    goto parse_error;
 
                 if (value == -1) {
+                    /* No digits were scanned. */
                     value = 0;
                     scale = 0;
+                } else if (scale == 0) {
+                    /* No decimal point. */
+                    scale = 1;
                 }
                 if (sign)
                     value *= sign;
 
-                *va_arg(ap, int *) = value;
-                *va_arg(ap, int *) = scale;
+                *va_arg(ap, struct minmea_float *) = (struct minmea_float) {value, scale};
             } break;
 
             case 'i': { // Integer value, default 0 (int).
-                int value;
+                int value = 0;
 
-                char *endptr;
-                value = strtol(field, &endptr, 10);
-                if (minmea_isfield(*endptr))
-                    goto end;
+                if (field) {
+                    char *endptr;
+                    value = strtol(field, &endptr, 10);
+                    if (minmea_isfield(*endptr))
+                        goto parse_error;
+                }
 
                 *va_arg(ap, int *) = value;
             } break;
@@ -170,17 +206,24 @@ bool minmea_scan(const char *sentence, const char *format, ...)
             case 's': { // String value (char *).
                 char *buf = va_arg(ap, char *);
 
-                while (minmea_isfield(*field))
-                    *buf++ = *field++;
+                if (field) {
+                    while (minmea_isfield(*field))
+                        *buf++ = *field++;
+                }
+
                 *buf = '\0';
             } break;
 
             case 't': { // NMEA talker+sentence identifier (char *).
+                // This field is always mandatory.
+                if (!field)
+                    goto parse_error;
+
                 if (field[0] != '$')
-                    goto end;
-                for (int i=0; i<5; i++)
-                    if (!minmea_isfield(field[1+i]))
-                        goto end;
+                    goto parse_error;
+                for (int f=0; f<5; f++)
+                    if (!minmea_isfield(field[1+f]))
+                        goto parse_error;
 
                 char *buf = va_arg(ap, char *);
                 memcpy(buf, field+1, 5);
@@ -191,16 +234,18 @@ bool minmea_scan(const char *sentence, const char *format, ...)
                 struct minmea_date *date = va_arg(ap, struct minmea_date *);
 
                 int d = -1, m = -1, y = -1;
-                // Always six digits.
-                for (int i=0; i<6; i++)
-                    if (!isdigit((unsigned char) field[i]))
-                        goto end_D;
 
-                d = strtol((char[]) {field[0], field[1], '\0'}, NULL, 10);
-                m = strtol((char[]) {field[2], field[3], '\0'}, NULL, 10);
-                y = strtol((char[]) {field[4], field[5], '\0'}, NULL, 10);
+                if (field && minmea_isfield(*field)) {
+                    // Always six digits.
+                    for (int f=0; f<6; f++)
+                        if (!isdigit((unsigned char) field[f]))
+                            goto parse_error;
+
+                    d = strtol((char[]) {field[0], field[1], '\0'}, NULL, 10);
+                    m = strtol((char[]) {field[2], field[3], '\0'}, NULL, 10);
+                    y = strtol((char[]) {field[4], field[5], '\0'}, NULL, 10);
+                }
 
-            end_D:
                 date->day = d;
                 date->month = m;
                 date->year = y;
@@ -210,30 +255,32 @@ bool minmea_scan(const char *sentence, const char *format, ...)
                 struct minmea_time *time = va_arg(ap, struct minmea_time *);
 
                 int h = -1, i = -1, s = -1, u = -1;
-                // Minimum required: integer time.
-                for (int i=0; i<6; i++)
-                    if (!isdigit((unsigned char) field[i]))
-                        goto end_T;
-
-                h = strtol((char[]) {field[0], field[1], '\0'}, NULL, 10);
-                i = strtol((char[]) {field[2], field[3], '\0'}, NULL, 10);
-                s = strtol((char[]) {field[4], field[5], '\0'}, NULL, 10);
-                field += 6;
-
-                // Extra: fractional time. Saved as microseconds.
-                if (*field++ == '.') {
-                    int value = 0;
-                    int scale = 1000000;
-                    while (isdigit((unsigned char) *field) && scale > 1) {
-                        value = (value * 10) + (*field++ - '0');
-                        scale /= 10;
+
+                if (field && minmea_isfield(*field)) {
+                    // Minimum required: integer time.
+                    for (int f=0; f<6; f++)
+                        if (!isdigit((unsigned char) field[f]))
+                            goto parse_error;
+
+                    h = strtol((char[]) {field[0], field[1], '\0'}, NULL, 10);
+                    i = strtol((char[]) {field[2], field[3], '\0'}, NULL, 10);
+                    s = strtol((char[]) {field[4], field[5], '\0'}, NULL, 10);
+                    field += 6;
+
+                    // Extra: fractional time. Saved as microseconds.
+                    if (*field++ == '.') {
+                        int value = 0;
+                        int scale = 1000000;
+                        while (isdigit((unsigned char) *field) && scale > 1) {
+                            value = (value * 10) + (*field++ - '0');
+                            scale /= 10;
+                        }
+                        u = value * scale;
+                    } else {
+                        u = 0;
                     }
-                    u = value * scale;
-                } else {
-                    u = 0;
                 }
 
-            end_T:
                 time->hours = h;
                 time->minutes = i;
                 time->seconds = s;
@@ -244,17 +291,16 @@ bool minmea_scan(const char *sentence, const char *format, ...)
             } break;
 
             default: { // Unknown.
-                goto end;
+                goto parse_error;
             } break;
         }
 
-        // Advance to next field.
         next_field();
     }
 
     result = true;
 
-end:
+parse_error:
     va_end(ap);
     return result;
 }
@@ -289,6 +335,10 @@ enum minmea_sentence_id minmea_sentence_id(const char *sentence)
         return MINMEA_SENTENCE_GSA;
     if (!strcmp(type+2, "GLL"))
         return MINMEA_SENTENCE_GLL;
+    if (!strcmp(type+2, "GST"))
+        return MINMEA_SENTENCE_GST;
+    if (!strcmp(type+2, "GSV"))
+        return MINMEA_SENTENCE_GSV;
 
     return MINMEA_UNKNOWN;
 }
@@ -305,20 +355,20 @@ bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence)
             type,
             &frame->time,
             &validity,
-            &frame->latitude, &frame->latitude_scale, &latitude_direction,
-            &frame->longitude, &frame->longitude_scale, &longitude_direction,
-            &frame->speed, &frame->speed_scale,
-            &frame->course, &frame->course_scale,
+            &frame->latitude, &latitude_direction,
+            &frame->longitude, &longitude_direction,
+            &frame->speed,
+            &frame->course,
             &frame->date,
-            &frame->variation, &frame->variation_scale, &variation_direction))
+            &frame->variation, &variation_direction))
         return false;
     if (strcmp(type+2, "RMC"))
         return false;
 
     frame->valid = (validity == 'A');
-    frame->latitude *= latitude_direction;
-    frame->longitude *= longitude_direction;
-    frame->variation *= variation_direction;
+    frame->latitude.value *= latitude_direction;
+    frame->longitude.value *= longitude_direction;
+    frame->variation.value *= variation_direction;
 
     return true;
 }
@@ -333,20 +383,20 @@ bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence)
     if (!minmea_scan(sentence, "tTfdfdiiffcfci_",
             type,
             &frame->time,
-            &frame->latitude, &frame->latitude_scale, &latitude_direction,
-            &frame->longitude, &frame->longitude_scale, &longitude_direction,
+            &frame->latitude, &latitude_direction,
+            &frame->longitude, &longitude_direction,
             &frame->fix_quality,
             &frame->satellites_tracked,
-            &frame->hdop, &frame->hdop_scale,
-            &frame->altitude, &frame->altitude_scale, &frame->altitude_units,
-            &frame->height, &frame->height_scale, &frame->height_units,
+            &frame->hdop,
+            &frame->altitude, &frame->altitude_units,
+            &frame->height, &frame->height_units,
             &frame->dgps_age))
         return false;
     if (strcmp(type+2, "GGA"))
         return false;
 
-    frame->latitude *= latitude_direction;
-    frame->longitude *= longitude_direction;
+    frame->latitude.value *= latitude_direction;
+    frame->longitude.value *= longitude_direction;
 
     return true;
 }
@@ -373,14 +423,9 @@ bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence)
             &frame->sats[10],
             &frame->sats[11],
             &frame->pdop,
-            &frame->pdop_scale,
             &frame->hdop,
-            &frame->hdop_scale,
-            &frame->vdop,
-            &frame->vdop_scale
-            )){
+            &frame->vdop))
         return false;
-    }
     if (strcmp(type+2, "GSA"))
         return false;
 
@@ -411,21 +456,78 @@ bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence)
     return true;
 }
 
+bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence)
+{
+    // $GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58
+    char type[6];
+
+    if (!minmea_scan(sentence, "tTfffffff",
+            type,
+            &frame->time,
+            &frame->rms_deviation,
+            &frame->semi_major_deviation,
+            &frame->semi_minor_deviation,
+            &frame->semi_major_orientation,
+            &frame->latitude_error_deviation,
+            &frame->longitude_error_deviation,
+            &frame->altitude_error_deviation))
+        return false;
+    if (strcmp(type+2, "GST"))
+        return false;
+
+    return true;
+}
+
+bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence)
+{
+    // $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74
+    char type[6];
+
+    if (!minmea_scan(sentence, "tiiiiiiiiiiiiiiiiiii",
+            type,
+            &frame->total_msgs,
+            &frame->msg_nr,
+            &frame->total_sats,
+            &frame->sats[0].nr,
+            &frame->sats[0].elevation,
+            &frame->sats[0].azimuth,
+            &frame->sats[0].snr,
+            &frame->sats[1].nr,
+            &frame->sats[1].elevation,
+            &frame->sats[1].azimuth,
+            &frame->sats[1].snr,
+            &frame->sats[2].nr,
+            &frame->sats[2].elevation,
+            &frame->sats[2].azimuth,
+            &frame->sats[2].snr,
+            &frame->sats[3].nr,
+            &frame->sats[3].elevation,
+            &frame->sats[3].azimuth,
+            &frame->sats[3].snr
+            )) {
+        return false;
+    }
+    if (strcmp(type+2, "GSV"))
+        return false;
+
+    return true;
+}
+
 int minmea_gettimeofday(struct timeval *tv, const struct minmea_date *date, const struct minmea_time *time)
 {
     if (date->year == -1 || time->hours == -1)
         return -1;
 
     struct tm tm;
+    memset(&tm, 0, sizeof(tm));
     tm.tm_year = 2000 + date->year - 1900;
     tm.tm_mon = date->month - 1;
     tm.tm_mday = date->day;
     tm.tm_hour = time->hours;
     tm.tm_min = time->minutes;
     tm.tm_sec = time->seconds;
-    tm.tm_isdst = 0;
-    time_t timestamp = timegm(&tm);
 
+    time_t timestamp = timegm(&tm);
     if (timestamp != -1) {
         tv->tv_sec = timestamp;
         tv->tv_usec = time->microseconds;

minmea.h

@@ -9,6 +9,8 @@
 #ifndef MINMEA_H
 #define MINMEA_H
 
+#define _BSD_SOURCE
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -29,7 +31,14 @@ enum minmea_sentence_id {
     MINMEA_SENTENCE_RMC,
     MINMEA_SENTENCE_GGA,
     MINMEA_SENTENCE_GSA,
-    MINMEA_SENTENCE_GLL
+    MINMEA_SENTENCE_GLL,
+    MINMEA_SENTENCE_GST,
+    MINMEA_SENTENCE_GSV,
+};
+
+struct minmea_float {
+    int_least32_t value;
+    int_least32_t scale;
 };
 
 struct minmea_date {
@@ -48,23 +57,23 @@ struct minmea_time {
 struct minmea_sentence_rmc {
     struct minmea_time time;
     bool valid;
-    int latitude, latitude_scale;
-    int longitude, longitude_scale;
-    int speed, speed_scale;
-    int course, course_scale;
+    struct minmea_float latitude;
+    struct minmea_float longitude;
+    struct minmea_float speed;
+    struct minmea_float course;
     struct minmea_date date;
-    int variation, variation_scale;
+    struct minmea_float variation;
 };
 
 struct minmea_sentence_gga {
     struct minmea_time time;
-    int latitude, latitude_scale;
-    int longitude, longitude_scale;
+    struct minmea_float latitude;
+    struct minmea_float longitude;
     int fix_quality;
     int satellites_tracked;
-    int hdop, hdop_scale;
-    int altitude, altitude_scale; char altitude_units;
-    int height, height_scale; char height_units;
+    struct minmea_float hdop;
+    struct minmea_float altitude; char altitude_units;
+    struct minmea_float height; char height_units;
     int dgps_age;
 };
 
@@ -86,6 +95,18 @@ struct minmea_sentence_gll {
     char status;
     char mode;
 };
+
+struct minmea_sentence_gst {
+    struct minmea_time time;
+    struct minmea_float rms_deviation;
+    struct minmea_float semi_major_deviation;
+    struct minmea_float semi_minor_deviation;
+    struct minmea_float semi_major_orientation;
+    struct minmea_float latitude_error_deviation;
+    struct minmea_float longitude_error_deviation;
+    struct minmea_float altitude_error_deviation;
+};
+
 enum minmea_gsa_mode {
     MINMEA_GPGSA_MODE_AUTO = 'A',
     MINMEA_GPGSA_MODE_FORCED = 'M',
@@ -101,9 +122,23 @@ struct minmea_sentence_gsa {
     char mode;
     int fix_type;
     int sats[12];
-    int pdop, pdop_scale;
-    int hdop, hdop_scale;
-    int vdop, vdop_scale;
+    struct minmea_float pdop;
+    struct minmea_float hdop;
+    struct minmea_float vdop;
+};
+
+struct minmea_sat_info {
+    int nr;
+    int elevation;
+    int azimuth;
+    int snr;
+};
+
+struct minmea_sentence_gsv {
+    int total_msgs;
+    int msg_nr;
+    int total_sats;
+    struct minmea_sat_info sats[4];
 };
 
 /**
@@ -141,6 +176,8 @@ bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence);
 bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence);
 bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence);
 bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence);
+bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence);
+bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence);
 
 /**
  * Convert GPS UTC date/time representation to a UNIX timestamp.
@@ -150,40 +187,40 @@ int minmea_gettimeofday(struct timeval *tv, const struct minmea_date *date, cons
 /**
  * Rescale a fixed-point value to a different scale. Rounds towards zero.
  */
-static inline int minmea_rescale(int value, int from, int to)
+static inline int_least32_t minmea_rescale(struct minmea_float *f, int_least32_t new_scale)
 {
-    if (from == 0)
+    if (f->scale == 0)
         return 0;
-    if (from == to)
-        return value;
-    if (from > to)
-        return (value + ((value > 0) - (value < 0)) * from/to/2) / (from/to);
+    if (f->scale == new_scale)
+        return f->value;
+    if (f->scale > new_scale)
+        return (f->value + ((f->value > 0) - (f->value < 0)) * f->scale/new_scale/2) / (f->scale/new_scale);
     else
-        return value * (to/from);
+        return f->value * (new_scale/f->scale);
 }
 
 /**
  * Convert a fixed-point value to a floating-point value.
  * Returns NaN for "unknown" values.
  */
-static inline float minmea_float(int value, int scale)
+static inline float minmea_tofloat(struct minmea_float *f)
 {
-    if (scale == 0)
+    if (f->scale == 0)
         return NAN;
-    return (float) value / (float) scale;
+    return (float) f->value / (float) f->scale;
 }
 
 /**
  * Convert a raw coordinate to a floating point DD.DDD... value.
  * Returns NaN for "unknown" values.
  */
-static inline float minmea_coord(int value, int scale)
+static inline float minmea_tocoord(struct minmea_float *f)
 {
-    if (scale == 0)
+    if (f->scale == 0)
         return NAN;
-    int degrees = value / (scale * 100);
-    int minutes = value % (scale * 100);
-    return (float) degrees + (float) minutes / (60 * scale);
+    int_least32_t degrees = f->value / (f->scale * 100);
+    int_least32_t minutes = f->value % (f->scale * 100);
+    return (float) degrees + (float) minutes / (60 * f->scale);
 }
 
 #ifdef __cplusplus

tests.c

@@ -6,6 +6,8 @@
  * published by Sam Hocevar. See the COPYING file for more details.
  */
 
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
@@ -32,6 +34,7 @@ static const char *valid_sequences[] = {
     "$GPGLL,5106.94086,N,01701.51680,E,123204.00,A,A*63",
     "$GPRMC,123205.00,A,5106.94085,N,01701.51689,E,0.016,,280214,,,A*7B",
     "$GPVTG,,T,,M,0.016,N,0.030,K,A*27",
+    "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58",
     NULL,
 };
 
@@ -61,7 +64,7 @@ END_TEST
 
 START_TEST(test_minmea_scan_c)
 {
-    char ch;
+    char ch, extra;
 
     ck_assert(minmea_scan("A,123.45", "c", &ch) == true);
     ck_assert_int_eq(ch, 'A');
@@ -71,6 +74,19 @@ START_TEST(test_minmea_scan_c)
 
     ck_assert(minmea_scan(",123.45", "c", &ch) == true);
     ck_assert_int_eq(ch, '\0');
+
+    ck_assert(minmea_scan("A,B", "cc", &ch, &extra) == true);
+    ck_assert_int_eq(ch, 'A');
+    ck_assert_int_eq(extra, 'B');
+
+    ck_assert(minmea_scan("C", "cc", &ch, &extra) == false);
+
+    ck_assert(minmea_scan("D", "c;c", &ch, &extra) == true);
+    ck_assert_int_eq(ch, 'D');
+    ck_assert_int_eq(extra, '\0');
+    ck_assert(minmea_scan("E,F", "c;c", &ch, &extra) == true);
+    ck_assert_int_eq(ch, 'E');
+    ck_assert_int_eq(extra, 'F');
 }
 END_TEST
 
@@ -96,41 +112,105 @@ END_TEST
 
 START_TEST(test_minmea_scan_f)
 {
-    int value, scale;
-
-    ck_assert(minmea_scan("-", "f", &value, &scale) == false);
-    ck_assert(minmea_scan("10-", "f", &value, &scale) == false);
-    ck_assert(minmea_scan("+-10", "f", &value, &scale) == false);
-    ck_assert(minmea_scan("12..45", "f", &value, &scale) == false);
-    ck_assert(minmea_scan("blah", "f", &value, &scale) == false);
-    ck_assert(minmea_scan("12.3.4", "f", &value, &scale) == false);
-
-    ck_assert(minmea_scan(",", "f", &value, &scale) == true);
-    ck_assert_int_eq(scale, 0);
-    ck_assert(minmea_scan("", "f", &value, &scale) == true);
-    ck_assert_int_eq(scale, 0);
-
-    ck_assert(minmea_scan("15.345", "f", &value, &scale) == true);
-    ck_assert_int_eq(value, 15345);
-    ck_assert_int_eq(scale, 1000);
-
-    ck_assert(minmea_scan("-1.23,V", "f", &value, &scale) == true);
-    ck_assert_int_eq(value, -123);
-    ck_assert_int_eq(scale, 100);
-
-    /* some GPS units have absurdly big precision. handle whatever int handles. */
-    ck_assert(minmea_scan("5106.94091", "f", &value, &scale) == true);
-    ck_assert_int_eq(value, 510694091);
-    ck_assert_int_eq(scale, 100000);
-
-    /* for now we support +-180 degrees with 5 decimal digits; anything
-     * more will overflow. */
-    ck_assert(minmea_scan("18000.00000", "f", &value, &scale) == true);
-    ck_assert_int_eq(value, 1800000000);
-    ck_assert_int_eq(scale, 100000);
-    ck_assert(minmea_scan("-18000.00000", "f", &value, &scale) == true);
-    ck_assert_int_eq(value, -1800000000);
-    ck_assert_int_eq(scale, 100000);
+    struct minmea_float f;
+
+    ck_assert(minmea_scan("-", "f", &f) == false);
+    ck_assert(minmea_scan("10-", "f", &f) == false);
+    ck_assert(minmea_scan("+-10", "f", &f) == false);
+    ck_assert(minmea_scan("12..45", "f", &f) == false);
+    ck_assert(minmea_scan("blah", "f", &f) == false);
+    ck_assert(minmea_scan("12.3.4", "f", &f) == false);
+
+    ck_assert(minmea_scan(",", "f", &f) == true);
+    ck_assert_int_eq(f.scale, 0);
+    ck_assert(minmea_scan("", "f", &f) == true);
+    ck_assert_int_eq(f.scale, 0);
+
+    ck_assert(minmea_scan("42", "f", &f) == true);
+    ck_assert_int_eq(f.value, 42);
+    ck_assert_int_eq(f.scale, 1);
+
+    ck_assert(minmea_scan("15.345", "f", &f) == true);
+    ck_assert_int_eq(f.value, 15345);
+    ck_assert_int_eq(f.scale, 1000);
+
+    ck_assert(minmea_scan("-1.23,V", "f", &f) == true);
+    ck_assert_int_eq(f.value, -123);
+    ck_assert_int_eq(f.scale, 100);
+
+    /* the guaranteed range is 32 bits which translates to +-180 degrees
+     * with 5 decimal digits. make sure we support that. */
+    ck_assert(minmea_scan("18000.00000", "f", &f) == true);
+    ck_assert_int_eq(f.value, 1800000000);
+    ck_assert_int_eq(f.scale, 100000);
+    ck_assert(minmea_scan("-18000.00000", "f", &f) == true);
+    ck_assert_int_eq(f.value, -1800000000);
+    ck_assert_int_eq(f.scale, 100000);
+
+    if (sizeof(int_least32_t) == 4) {
+        /* fits in 32 bits */
+        ck_assert(minmea_scan("2147483647", "f", &f) == true);
+        ck_assert_int_eq(f.value, 2147483647);
+        ck_assert_int_eq(f.scale, 1);
+        /* doesn't fit, truncate precision */
+        ck_assert(minmea_scan("2147483.648", "f", &f) == true);
+        ck_assert_int_eq(f.value, 214748364);
+        ck_assert_int_eq(f.scale, 100);
+        /* doesn't fit, bail out */
+        ck_assert(minmea_scan("2147483648", "f", &f) == false);
+    } else if (sizeof(int_least32_t) == 8) {
+        /* fits in 64 bits */
+        ck_assert(minmea_scan("9223372036854775807", "f", &f) == true);
+        ck_assert_int_eq(f.value, 9223372036854775807);
+        ck_assert_int_eq(f.scale, 1);
+        /* doesn't fit, truncate precision */
+        ck_assert(minmea_scan("9223372036854775.808", "f", &f) == true);
+        ck_assert_int_eq(f.value, 922337203685477580);
+        ck_assert_int_eq(f.scale, 100);
+        /* doesn't fit, bail out */
+        ck_assert(minmea_scan("9223372036854775808", "f", &f) == false);
+    } else {
+        ck_abort_msg("your platform is esoteric. please fix this unit test.");
+    }
+
+    /* optional f.values */
+    ck_assert(minmea_scan("foo", "_;f", &f) == true);
+    ck_assert_int_eq(f.scale, 0);
+    ck_assert(minmea_scan("foo,", "_;f", &f) == true);
+    ck_assert_int_eq(f.scale, 0);
+    ck_assert(minmea_scan("foo,12.3", "_;f", &f) == true);
+    ck_assert_int_eq(f.value, 123);
+    ck_assert_int_eq(f.scale, 10);
+}
+END_TEST
+
+START_TEST(test_minmea_scan_i)
+{
+    int value, extra;
+
+    // valid parses
+    ck_assert(minmea_scan("14", "i", &value) == true);
+    ck_assert_int_eq(value, 14);
+    ck_assert(minmea_scan("-1234", "i", &value) == true);
+    ck_assert_int_eq(value, -1234);
+
+    // empty field
+    ck_assert(minmea_scan("", "i", &value) == true);
+    ck_assert_int_eq(value, 0);
+
+    // invalid value
+    ck_assert(minmea_scan("foo", "i", &value) == false);
+
+    // missing field
+    ck_assert(minmea_scan("41", "ii", &value, &extra) == false);
+
+    /* optional values */
+    ck_assert(minmea_scan("10", "i;i", &value, &extra) == true);
+    ck_assert_int_eq(value, 10);
+    ck_assert(minmea_scan("20,30", "i;i", &value, &extra) == true);
+    ck_assert_int_eq(value, 20);
+    ck_assert_int_eq(extra, 30);
+    ck_assert(minmea_scan("42,foo", "i;i", &value, &extra) == false);
 }
 END_TEST
 
@@ -138,9 +218,16 @@ START_TEST(test_minmea_scan_s)
 {
     char value[MINMEA_MAX_LENGTH];
 
+    ck_assert(minmea_scan(",bar,baz", "s", value) == true);
+    ck_assert_str_eq(value, "");
     ck_assert(minmea_scan("foo,bar,baz", "s", value) == true);
     ck_assert_str_eq(value, "foo");
-    ck_assert(minmea_scan(",bar,baz", "s", value) == true);
+
+    ck_assert(minmea_scan("dummy", "_;s", value) == true);
+    ck_assert_str_eq(value, "");
+    ck_assert(minmea_scan("dummy,foo", "_;s", value) == true);
+    ck_assert_str_eq(value, "foo");
+    ck_assert(minmea_scan("dummy,", "_;s", value) == true);
     ck_assert_str_eq(value, "");
 }
 END_TEST
@@ -164,6 +251,9 @@ START_TEST(test_minmea_scan_D)
 {
     struct minmea_date date;
 
+    ck_assert(minmea_scan("$GPXXX,3112", "_D", &date) == false);
+    ck_assert(minmea_scan("$GPXXX,foobar", "_D", &date) == false);
+
     ck_assert(minmea_scan("$GPXXX,311299", "_D", &date) == true);
     ck_assert_int_eq(date.day, 31);
     ck_assert_int_eq(date.month, 12);
@@ -180,6 +270,9 @@ START_TEST(test_minmea_scan_T)
 {
     struct minmea_time time;
 
+    ck_assert(minmea_scan("$GPXXX,2359", "_T", &time) == false);
+    ck_assert(minmea_scan("$GPXXX,foobar", "_T", &time) == false);
+
     ck_assert(minmea_scan("$GPXXX,235960", "_T", &time) == true);
     ck_assert_int_eq(time.hours, 23);
     ck_assert_int_eq(time.minutes, 59);
@@ -205,42 +298,42 @@ START_TEST(test_minmea_scan_complex1)
     const char *sentence = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47\r\n";
     char type[6];
     struct minmea_time time;
-    int latitude, latitude_scale, latitude_direction;
-    int longitude, longitude_scale, longitude_direction;
+    struct minmea_float latitude; int latitude_direction;
+    struct minmea_float longitude; int longitude_direction;
     int fix_quality;
     int satellites;
-    int hdop, hdop_scale;
-    int altitude, altitude_scale; char altitude_units;
-    int height, height_scale; char height_units;
+    struct minmea_float hdop;
+    struct minmea_float altitude; char altitude_units;
+    struct minmea_float height; char height_units;
     ck_assert(minmea_scan(sentence, "tTfdfdiiffcfc__",
         type,
         &time,
-        &latitude, &latitude_scale, &latitude_direction,
-        &longitude, &longitude_scale, &longitude_direction,
+        &latitude, &latitude_direction,
+        &longitude, &longitude_direction,
         &fix_quality,
         &satellites,
-        &hdop, &hdop_scale,
-        &altitude, &altitude_scale, &altitude_units,
-        &height, &height_scale, &height_units) == true);
+        &hdop,
+        &altitude, &altitude_units,
+        &height, &height_units) == true);
     ck_assert_str_eq(type, "GPGGA");
     ck_assert_int_eq(time.hours, 12);
     ck_assert_int_eq(time.minutes, 35);
     ck_assert_int_eq(time.seconds, 19);
-    ck_assert_int_eq(latitude, 4807038);
-    ck_assert_int_eq(latitude_scale, 1000);
+    ck_assert_int_eq(latitude.value, 4807038);
+    ck_assert_int_eq(latitude.scale, 1000);
     ck_assert_int_eq(latitude_direction, 1);
-    ck_assert_int_eq(longitude, 1131000);
-    ck_assert_int_eq(longitude_scale, 1000);
+    ck_assert_int_eq(longitude.value, 1131000);
+    ck_assert_int_eq(longitude.scale, 1000);
     ck_assert_int_eq(longitude_direction, 1);
     ck_assert_int_eq(fix_quality, 1);
     ck_assert_int_eq(satellites, 8);
-    ck_assert_int_eq(hdop, 9);
-    ck_assert_int_eq(hdop_scale, 10);
-    ck_assert_int_eq(altitude, 5454);
-    ck_assert_int_eq(altitude_scale, 10);
+    ck_assert_int_eq(hdop.value, 9);
+    ck_assert_int_eq(hdop.scale, 10);
+    ck_assert_int_eq(altitude.value, 5454);
+    ck_assert_int_eq(altitude.scale, 10);
     ck_assert_int_eq(altitude_units, 'M');
-    ck_assert_int_eq(height, 469);
-    ck_assert_int_eq(height_scale, 10);
+    ck_assert_int_eq(height.value, 469);
+    ck_assert_int_eq(height.scale, 10);
     ck_assert_int_eq(height_units, 'M');
 
 }
@@ -251,57 +344,96 @@ START_TEST(test_minmea_scan_complex2)
     const char *sentence = "$GPBWC,081837,,,,,,T,,M,,N,*13";
     char type[6];
     struct minmea_time time;
-    int latitude, latitude_scale, latitude_direction;
-    int longitude, longitude_scale, longitude_direction;
-    int bearing_true, bearing_true_scale; char bearing_true_mark;
-    int bearing_magnetic, bearing_magnetic_scale; char bearing_magnetic_mark;
-    int distance, distance_scale; char distance_units;
+    struct minmea_float latitude; int latitude_direction;
+    struct minmea_float longitude; int longitude_direction;
+    struct minmea_float bearing_true; char bearing_true_mark;
+    struct minmea_float bearing_magnetic; char bearing_magnetic_mark;
+    struct minmea_float distance; char distance_units;
     char name[MINMEA_MAX_LENGTH];
     ck_assert(minmea_scan(sentence, "tTfdfdfcfcfcs",
         type,
         &time,
-        &latitude, &latitude_scale, &latitude_direction,
-        &longitude, &longitude_scale, &longitude_direction,
-        &bearing_true, &bearing_true_scale, &bearing_true_mark,
-        &bearing_magnetic, &bearing_magnetic_scale, &bearing_magnetic_mark,
-        &distance, &distance_scale, &distance_units,
+        &latitude, &latitude_direction,
+        &longitude, &longitude_direction,
+        &bearing_true, &bearing_true_mark,
+        &bearing_magnetic, &bearing_magnetic_mark,
+        &distance, &distance_units,
         name) == true);
     ck_assert_str_eq(type, "GPBWC");
     ck_assert_int_eq(time.hours, 8);
     ck_assert_int_eq(time.minutes, 18);
     ck_assert_int_eq(time.seconds, 37);
-    ck_assert_int_eq(latitude_scale, 0);
+    ck_assert_int_eq(latitude.scale, 0);
     ck_assert_int_eq(latitude_direction, 0);
-    ck_assert_int_eq(longitude_scale, 0);
+    ck_assert_int_eq(longitude.scale, 0);
     ck_assert_int_eq(longitude_direction, 0);
-    ck_assert_int_eq(bearing_true_scale, 0);
+    ck_assert_int_eq(bearing_true.scale, 0);
     ck_assert_int_eq(bearing_true_mark, 'T');
-    ck_assert_int_eq(bearing_magnetic_scale, 0);
+    ck_assert_int_eq(bearing_magnetic.scale, 0);
     ck_assert_int_eq(bearing_magnetic_mark, 'M');
-    ck_assert_int_eq(distance_scale, 0);
+    ck_assert_int_eq(distance.scale, 0);
     ck_assert_int_eq(distance_units, 'N');
     ck_assert_str_eq(name, "");
 }
 END_TEST
 
+START_TEST(test_minmea_scan_complex3)
+{
+    const char *sentence = "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58";
+    char type[6];
+    struct minmea_time time;
+    struct minmea_float rms_deviation;
+    struct minmea_float semi_major_deviation;
+    struct minmea_float semi_minor_deviation;
+    struct minmea_float semi_major_orientation;
+    struct minmea_float latitude_error_deviation;
+    struct minmea_float longitude_error_deviation;
+    struct minmea_float altitude_error_deviation;
+    ck_assert(minmea_scan(sentence, "tTfffffff",
+        type,
+        &time,
+        &rms_deviation,
+        &semi_major_deviation,
+        &semi_minor_deviation,
+        &semi_major_orientation,
+        &latitude_error_deviation,
+        &longitude_error_deviation,
+        &altitude_error_deviation) == true);
+    ck_assert_str_eq(type, "GPGST");
+    ck_assert_int_eq(time.hours, 2);
+    ck_assert_int_eq(time.minutes, 46);
+    ck_assert_int_eq(time.seconds, 3);
+    ck_assert_int_eq(time.microseconds, 0);
+    ck_assert_int_eq(rms_deviation.value, 32);
+    ck_assert_int_eq(rms_deviation.scale, 10);
+    ck_assert_int_eq(semi_major_deviation.value, 66);
+    ck_assert_int_eq(semi_major_deviation.scale, 10);
+    ck_assert_int_eq(semi_minor_deviation.value, 47);
+    ck_assert_int_eq(semi_minor_deviation.scale, 10);
+    ck_assert_int_eq(semi_major_orientation.value, 473);
+    ck_assert_int_eq(semi_major_orientation.scale, 10);
+    ck_assert_int_eq(latitude_error_deviation.value, 58);
+    ck_assert_int_eq(latitude_error_deviation.scale, 10);
+    ck_assert_int_eq(longitude_error_deviation.value, 56);
+    ck_assert_int_eq(longitude_error_deviation.scale, 10);
+    ck_assert_int_eq(altitude_error_deviation.value, 220);
+    ck_assert_int_eq(altitude_error_deviation.scale, 10);
+}
+END_TEST
+
 START_TEST(test_minmea_parse_rmc1)
 {
     const char *sentence = "$GPRMC,081836.75,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E";
     struct minmea_sentence_rmc frame = {};
-    struct minmea_sentence_rmc expected = {
+    static const struct minmea_sentence_rmc expected = {
         .time = { 8, 18, 36, 750000 },
         .valid = true,
-        .latitude = -375165,
-        .latitude_scale = 100,
-        .longitude = 1450736,
-        .longitude_scale = 100,
-        .speed = 0,
-        .speed_scale = 10,
-        .course = 3600,
-        .course_scale = 10,
+        .latitude = { -375165, 100 },
+        .longitude = { 1450736, 100 },
+        .speed = { 0, 10 },
+        .course = { 3600, 10 },
         .date = { 13, 9, 98 },
-        .variation = 113,
-        .variation_scale = 10,
+        .variation = { 113, 10 },
     };
     ck_assert(minmea_check(sentence) == true);
     ck_assert(minmea_parse_rmc(&frame, sentence) == true);
@@ -313,13 +445,11 @@ START_TEST(test_minmea_parse_rmc2)
 {
     const char *sentence = "$GPRMC,,A,3751.65,N,14507.36,W,,,,,";
     struct minmea_sentence_rmc frame = {};
-    struct minmea_sentence_rmc expected = {
+    static const struct minmea_sentence_rmc expected = {
         .time = { -1, -1, -1, -1 },
         .valid = true,
-        .latitude = 375165,
-        .latitude_scale = 100,
-        .longitude = -1450736,
-        .longitude_scale = 100,
+        .latitude = { 375165, 100 },
+        .longitude = { -1450736, 100 },
         .date = { -1, -1, -1 },
     };
     ck_assert(minmea_check(sentence) == true);
@@ -332,21 +462,16 @@ START_TEST(test_minmea_parse_gga1)
 {
     const char *sentence = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47";
     struct minmea_sentence_gga frame = {};
-    struct minmea_sentence_gga expected = {
+    static const struct minmea_sentence_gga expected = {
         .time = { 12, 35, 19, 0 },
-        .latitude = 4807038,
-        .latitude_scale = 1000,
-        .longitude = 1131000,
-        .longitude_scale = 1000,
+        .latitude = { 4807038, 1000 },
+        .longitude = { 1131000, 1000 },
         .fix_quality = 1,
         .satellites_tracked = 8,
-        .hdop = 9,
-        .hdop_scale = 10,
-        .altitude = 5454,
-        .altitude_scale = 10,
+        .hdop = { 9, 10 },
+        .altitude = { 5454, 10 },
         .altitude_units = 'M',
-        .height = 469,
-        .height_scale = 10,
+        .height = { 469, 10 },
         .height_units = 'M',
         .dgps_age = 0,
     };
@@ -356,20 +481,37 @@ START_TEST(test_minmea_parse_gga1)
 }
 END_TEST
 
+START_TEST(test_minmea_parse_gst1)
+{
+    const char *sentence = "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58";
+    struct minmea_sentence_gst frame = {};
+    struct minmea_sentence_gst expected = {
+        .time = { 2, 46, 3, 0 },
+        .rms_deviation = { 32, 10 },
+        .semi_major_deviation = { 66, 10 },
+        .semi_minor_deviation = { 47, 10 },
+        .semi_major_orientation = { 473, 10 },
+        .latitude_error_deviation = { 58, 10 },
+        .longitude_error_deviation = { 56, 10 },
+        .altitude_error_deviation = { 220, 10 },
+    };
+    ck_assert(minmea_check(sentence) == true);
+    ck_assert(minmea_parse_gst(&frame, sentence) == true);
+    ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
+}
+END_TEST
+
 START_TEST(test_minmea_parse_gsa1)
 {
     const char *sentence = "$GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39";
     struct minmea_sentence_gsa frame = {};
-    struct minmea_sentence_gsa expected = {
+    static const struct minmea_sentence_gsa expected = {
         .mode = MINMEA_GPGSA_MODE_AUTO,
         .fix_type = MINMEA_GPGSA_FIX_3D,
         .sats = { 4, 5, 0, 9, 12, 0, 0, 24, 0, 0, 0, 0 },
-        .pdop = 25,
-        .pdop_scale = 10,
-        .hdop = 13,
-        .hdop_scale = 10,
-        .vdop = 21,
-        .vdop_scale = 10
+        .pdop = { 25, 10 },
+        .hdop = { 13, 10 },
+        .vdop = { 21, 10 },
     };
     ck_assert(minmea_check(sentence) == true);
     ck_assert(minmea_parse_gsa(&frame, sentence) == true);
@@ -400,6 +542,47 @@ START_TEST(test_minmea_parse_gpgll)
 }
 END_TEST
 
+START_TEST(test_minmea_parse_gsv1)
+{
+    const char *sentence = "$GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D";
+    struct minmea_sentence_gsv frame = {};
+    static const struct minmea_sentence_gsv expected = {
+        .total_msgs = 3,
+        .msg_nr = 3,
+        .total_sats = 11,
+        .sats = {
+            {
+                .nr = 22,
+                .elevation = 42,
+                .azimuth = 67,
+                .snr = 42
+            },
+            {
+                .nr = 24,
+                .elevation = 14,
+                .azimuth = 311,
+                .snr = 43
+            },
+            {
+                .nr = 27,
+                .elevation = 5,
+                .azimuth = 244,
+                .snr = 0
+            },
+            {
+                .nr = 0,
+                .elevation = 0,
+                .azimuth = 0,
+                .snr = 0
+            }
+        }
+    };
+    ck_assert(minmea_check(sentence) == true);
+    ck_assert(minmea_parse_gsv(&frame, sentence) == true);
+    ck_assert(!memcmp(&frame, &expected, sizeof(frame)));
+}
+END_TEST
+
 START_TEST(test_minmea_usage1)
 {
     const char *sentences[] = {
@@ -407,6 +590,7 @@ START_TEST(test_minmea_usage1)
         "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47",
         "$GNGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1",
         "$GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41",
+        "$GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58",
         NULL,
     };
 
@@ -416,12 +600,12 @@ START_TEST(test_minmea_usage1)
                 struct minmea_sentence_rmc frame;
                 ck_assert(minmea_parse_rmc(&frame, *sentence) == true);
             } break;
-            
+
             case MINMEA_SENTENCE_GGA: {
                 struct minmea_sentence_gga frame;
                 ck_assert(minmea_parse_gga(&frame, *sentence) == true);
             } break;
-            
+
             case MINMEA_SENTENCE_GSA: {
                 struct minmea_sentence_gsa frame;
                 ck_assert(minmea_parse_gsa(&frame, *sentence) == true);
@@ -432,6 +616,10 @@ START_TEST(test_minmea_usage1)
                 ck_assert(minmea_parse_gll(&frame, *sentence) == true);
             } break;
 
+            case MINMEA_SENTENCE_GST: {
+                struct minmea_sentence_gst frame;
+                ck_assert(minmea_parse_gst(&frame, *sentence) == true);
+            } break;
 
             default: {
             } break;
@@ -466,43 +654,50 @@ END_TEST
 START_TEST(test_minmea_rescale)
 {
     /* basic and edge cases. */
-    ck_assert_int_eq(minmea_rescale(42, 0, 3), 0);
-    ck_assert_int_eq(minmea_rescale(1234, 10, 1), 123);
-    ck_assert_int_eq(minmea_rescale(1235, 10, 1), 124);
-    ck_assert_int_eq(minmea_rescale(1234, 10, 1000), 123400);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 42, 0 }, 3), 0);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 1234, 10 }, 1), 123);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 1235, 10 }, 1), 124);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 1234, 10 }, 1000), 123400);
 
     /* round towards zero. */
-    ck_assert_int_eq(minmea_rescale(-1234, 10, 1), -123);
-    ck_assert_int_eq(minmea_rescale(-1235, 10, 1), -124);
-    ck_assert_int_eq(minmea_rescale(-1236, 10, 1), -124);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { -1234, 10 }, 1), -123);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { -1235, 10 }, 1), -124);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { -1236, 10 }, 1), -124);
 
     /* shouldn't overflow on large numbers. */
-    ck_assert_int_eq(minmea_rescale(510693608, 100000, 10000), 51069361);
+    ck_assert_int_eq(minmea_rescale(&(struct minmea_float) { 510693608, 100000 }, 10000), 51069361);
 }
 END_TEST
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+/* The float values used in tests should be exactly representable under IEEE754;
+ * false negatives will occur otherwise. */
+
 START_TEST(test_minmea_float)
 {
-    ck_assert(isnan(minmea_float(42, 0)));
-    ck_assert(minmea_float(7, 1) == 7.0);
-    ck_assert(minmea_float(-200, 100) == -2.0);
-    ck_assert(minmea_float(15, 10) == 1.5);
+    ck_assert(isnan(minmea_tofloat(&(struct minmea_float) { 42, 0 })));
+    ck_assert(minmea_tofloat(&(struct minmea_float) { 7, 1}) == 7.0);
+    ck_assert(minmea_tofloat(&(struct minmea_float) { -200, 100}) == -2.0);
+    ck_assert(minmea_tofloat(&(struct minmea_float) { 15, 10}) == 1.5);
 }
 END_TEST
 
 START_TEST(test_minmea_coord)
 {
-    ck_assert(isnan(minmea_coord(42, 0)));
-    ck_assert(minmea_coord(4200, 1) == 42.0);
-    ck_assert(minmea_coord(420000, 100) == 42.0);
-    ck_assert(minmea_coord(423000, 100) == 42.5);
+    ck_assert(isnan(minmea_tocoord(&(struct minmea_float) { 42, 0 })));
+    ck_assert(minmea_tocoord(&(struct minmea_float) { 4200, 1 }) == 42.0);
+    ck_assert(minmea_tocoord(&(struct minmea_float) { 420000, 100 }) == 42.0);
+    ck_assert(minmea_tocoord(&(struct minmea_float) { 423000, 100 }) == 42.5);
 }
 END_TEST
 
+#pragma GCC diagnostic pop
+
 Suite *minmea_suite(void)
 {
     Suite *s = suite_create ("minmea");
-  
+
     TCase *tc_check = tcase_create("minmea_check");
     tcase_add_test(tc_check, test_minmea_check);
     suite_add_tcase(s, tc_check);
@@ -511,20 +706,24 @@ Suite *minmea_suite(void)
     tcase_add_test(tc_scan, test_minmea_scan_c);
     tcase_add_test(tc_scan, test_minmea_scan_d);
     tcase_add_test(tc_scan, test_minmea_scan_f);
+    tcase_add_test(tc_scan, test_minmea_scan_i);
     tcase_add_test(tc_scan, test_minmea_scan_s);
     tcase_add_test(tc_scan, test_minmea_scan_t);
     tcase_add_test(tc_scan, test_minmea_scan_D);
     tcase_add_test(tc_scan, test_minmea_scan_T);
     tcase_add_test(tc_scan, test_minmea_scan_complex1);
     tcase_add_test(tc_scan, test_minmea_scan_complex2);
+    tcase_add_test(tc_scan, test_minmea_scan_complex3);
     suite_add_tcase(s, tc_scan);
-  
+
     TCase *tc_parse = tcase_create("minmea_parse");
     tcase_add_test(tc_parse, test_minmea_parse_rmc1);
     tcase_add_test(tc_parse, test_minmea_parse_rmc2);
     tcase_add_test(tc_parse, test_minmea_parse_gga1);
     tcase_add_test(tc_parse, test_minmea_parse_gsa1);
     tcase_add_test(tc_parse, test_minmea_parse_gpgll);
+    tcase_add_test(tc_parse, test_minmea_parse_gst1);
+    tcase_add_test(tc_parse, test_minmea_parse_gsv1);
     suite_add_tcase(s, tc_parse);
 
     TCase *tc_usage = tcase_create("minmea_usage");