GPS update

ReadMe.md

@@ -23,6 +23,7 @@
 - - With speed optimizations by RogueMaster. 
 - - Rename the [minimal animation file](https://github.com/RogueMaster/flipperzero-firmware-wPlugins/blob/420/assets/resources/dolphin/manifest.txt.exampleMin) to see it, or [RM select](https://github.com/RogueMaster/flipperzero-firmware-wPlugins/blob/420/assets/resources/dolphin/manifest.txt.exampleRM) if you have copied over [the RM select](https://github.com/RogueMaster/awesome-flipperzero-withModules/tree/rogue_main/dolphin-RMselect) animations.
 - Updated: [i2c Tools (By NaejEL)](https://github.com/NaejEL/flipperzero-i2ctools)
+- Updated: [GPS (By ezod)](https://github.com/ezod/flipperzero-gps) `Req: NMEA 0183`
 
 <details>
   <summary><B>TO DO / REMOVED</b></summary><br/>

applications/plugins/gps_nmea_uart/README.md

@@ -1,15 +1,42 @@
 # GPS for Flipper Zero
 
-[Original link](https://github.com/ezod/flipperzero-gps)
+A simple Flipper Zero application for NMEA 0183 serial GPS modules, such as the
+[Adafruit Ultimate GPS Breakout].
 
-A simple Flipper Zero application for NMEA 0183 serial GPS modules, such as the [Adafruit Ultimate GPS Breakout].
+![ui](ui.png)
 
-Heavy lifting (NMEA parsing) provided by [minmea], which is included in this repository.
+Heavy lifting (NMEA parsing) provided by [minmea], which is included in this
+repository.
 
 ## Hardware Setup
 
-Connect the GPS module to power and the USART using GPIO pins 9 (3.3V), 11 (GND), 13 (TX), and 14 (RX), as appropriate.
+Connect the GPS module to power and the USART using GPIO pins 9 (3.3V), 11
+(GND), 13 (TX), and 14 (RX), as appropriate.
+
+![wiring](wiring.png)
+
+## Building the FAP
+
+1. Clone the [flipperzero-firmware] repository.
+2. Create a symbolic link in `applications_user` named `gps`, pointing to this
+   repository.
+3. Compile with `./fbt fap_gps`.
+4. Copy `build/f7-firmware-D/.extapps/gps.fap` to `apps/Tools` on the SD card
+   (directly or using [qFlipper]).
+
+## Contributing
+
+This project was a learning exercise and is more or less "complete" from my
+perspective, but I will happily accept pull requests that improve and enhance
+the functionality for others.
+
+Currently, the app only parses RMC and GGA sentences, and displays a subset of
+the data that fits on the screen. The UART is also hard-coded to 9600 baud.
+These limitations are largely driven by the GPS module I have to work with. A
+more elaborate UI with scrolling or multiple screens, as well as a configurable
+baud rate, may be useful for other GPS modules.
 
 [Adafruit Ultimate GPS Breakout]: https://www.adafruit.com/product/746
 [minmea]: https://github.com/kosma/minmea
 [flipperzero-firmware]: https://github.com/flipperdevices/flipperzero-firmware
+[qFlipper]: https://flipperzero.one/update

applications/plugins/gps_nmea_uart/gps.c

@@ -4,58 +4,66 @@
 #include <gui/gui.h>
 #include <string.h>
 
-typedef enum {
+typedef enum
+{
   EventTypeTick,
   EventTypeKey,
 } EventType;
 
-typedef struct {
+typedef struct
+{
   EventType type;
   InputEvent input;
 } PluginEvent;
 
-static void render_callback(Canvas* const canvas, void* context) {
+static void render_callback(Canvas* const canvas, void* context)
+{
   const GpsUart* gps_uart = acquire_mutex((ValueMutex*)context, 25);
-    if(gps_uart == NULL) {
+  if (gps_uart == NULL)
+  {
     return;
   }
 
+  canvas_set_font(canvas, FontPrimary);
+  canvas_draw_str_aligned(canvas, 32, 8, AlignCenter, AlignBottom, "Latitude");
+  canvas_draw_str_aligned(canvas, 96, 8, AlignCenter, AlignBottom, "Longitude");
+  canvas_draw_str_aligned(canvas, 21, 30, AlignCenter, AlignBottom, "Course");
+  canvas_draw_str_aligned(canvas, 64, 30, AlignCenter, AlignBottom, "Speed");
+  canvas_draw_str_aligned(canvas, 107, 30, AlignCenter, AlignBottom, "Altitude");
+  canvas_draw_str_aligned(canvas, 32, 52, AlignCenter, AlignBottom, "Satellites");
+  canvas_draw_str_aligned(canvas, 96, 52, AlignCenter, AlignBottom, "Last Fix");
+
   canvas_set_font(canvas, FontSecondary);
   char buffer[64];
-    snprintf(buffer, 64, "LAT: %f", (double)gps_uart->status.latitude);
+  snprintf(buffer, 64, "%f", (double)gps_uart->status.latitude);
-    canvas_draw_str_aligned(canvas, 10, 10, AlignLeft, AlignBottom, buffer);
+  canvas_draw_str_aligned(canvas, 32, 18, AlignCenter, AlignBottom, buffer);
-    snprintf(buffer, 64, "LON: %f", (double)gps_uart->status.longitude);
+  snprintf(buffer, 64, "%f", (double)gps_uart->status.longitude);
-    canvas_draw_str_aligned(canvas, 10, 20, AlignLeft, AlignBottom, buffer);
+  canvas_draw_str_aligned(canvas, 96, 18, AlignCenter, AlignBottom, buffer);
-    snprintf(
+  snprintf(buffer, 64, "%.1f", (double)gps_uart->status.course);
-        buffer,
+  canvas_draw_str_aligned(canvas, 21, 40, AlignCenter, AlignBottom, buffer);
-        64,
+  snprintf(buffer, 64, "%.2f kn", (double)gps_uart->status.speed);
-        "C/S: %.1f / %.2fkn",
+  canvas_draw_str_aligned(canvas, 64, 40, AlignCenter, AlignBottom, buffer);
-        (double)gps_uart->status.course,
+  snprintf(buffer, 64, "%.1f %c", (double)gps_uart->status.altitude, tolower(gps_uart->status.altitude_units));
-        (double)gps_uart->status.speed);
+  canvas_draw_str_aligned(canvas, 107, 40, AlignCenter, AlignBottom, buffer);
-    canvas_draw_str_aligned(canvas, 10, 30, AlignLeft, AlignBottom, buffer);
+  snprintf(buffer, 64, "%d", gps_uart->status.satellites_tracked);
-    snprintf(
+  canvas_draw_str_aligned(canvas, 32, 62, AlignCenter, AlignBottom, buffer);
-        buffer,
+  snprintf(buffer, 64, "%02d:%02d:%02d UTC", gps_uart->status.time_hours, gps_uart->status.time_minutes,
-        64,
+           gps_uart->status.time_seconds);
-        "ALT: %.1f %c",
+  canvas_draw_str_aligned(canvas, 96, 62, AlignCenter, AlignBottom, buffer);
-        (double)gps_uart->status.altitude,
-        gps_uart->status.altitude_units);
-    canvas_draw_str_aligned(canvas, 10, 40, AlignLeft, AlignBottom, buffer);
-    snprintf(buffer, 64, "FIX: %d", gps_uart->status.fix_quality);
-    canvas_draw_str_aligned(canvas, 10, 50, AlignLeft, AlignBottom, buffer);
-    snprintf(buffer, 64, "SAT: %d", gps_uart->status.satellites_tracked);
-    canvas_draw_str_aligned(canvas, 10, 60, AlignLeft, AlignBottom, buffer);
 
   release_mutex((ValueMutex*)context, gps_uart);
 }
 
-static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
+static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue)
+{
   furi_assert(event_queue);
 
   PluginEvent event = {.type = EventTypeKey, .input = *input_event};
   furi_message_queue_put(event_queue, &event, FuriWaitForever);
 }
 
-int32_t gps_app(void* p) {
+int32_t gps_app(void* p)
+{
   UNUSED(p);
 
   FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
@@ -63,7 +71,8 @@ int32_t gps_app(void* p) {
   GpsUart* gps_uart = gps_uart_enable();
 
   ValueMutex gps_uart_mutex;
-    if(!init_mutex(&gps_uart_mutex, gps_uart, sizeof(GpsUart))) {
+  if (!init_mutex(&gps_uart_mutex, gps_uart, sizeof(GpsUart)))
+  {
     FURI_LOG_E("GPS", "cannot create mutex\r\n");
     free(gps_uart);
     return 255;
@@ -79,16 +88,21 @@ int32_t gps_app(void* p) {
   gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
   PluginEvent event;
-    for(bool processing = true; processing;) {
+  for (bool processing = true; processing;)
+  {
     FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
     GpsUart* gps_uart = (GpsUart*)acquire_mutex_block(&gps_uart_mutex);
 
-        if(event_status == FuriStatusOk) {
+    if (event_status == FuriStatusOk)
+    {
       // press events
-            if(event.type == EventTypeKey) {
+      if (event.type == EventTypeKey)
-                if(event.input.type == InputTypePress) {
+      {
-                    switch(event.input.key) {
+        if (event.input.type == InputTypePress)
+        {
+          switch (event.input.key)
+          {
             case InputKeyUp:
             case InputKeyDown:
             case InputKeyRight:
@@ -101,7 +115,9 @@ int32_t gps_app(void* p) {
           }
         }
       }
-        } else {
+    } 
+    else
+    {
       FURI_LOG_D("GPS", "FuriMessageQueue: event timeout");
     }
 

applications/plugins/gps_nmea_uart/gps_uart.c

@@ -3,56 +3,77 @@
 #include "minmea.h"
 #include "gps_uart.h"
 
-typedef enum {
+typedef enum
+{
   WorkerEvtStop = (1 << 0),
   WorkerEvtRxDone = (1 << 1),
 } WorkerEvtFlags;
 
 #define WORKER_ALL_RX_EVENTS (WorkerEvtStop | WorkerEvtRxDone)
 
-static void gps_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
+static void gps_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context)
+{
   GpsUart* gps_uart = (GpsUart*)context;
 
-    if(ev == UartIrqEventRXNE) {
+  if (ev == UartIrqEventRXNE)
+  {
     furi_stream_buffer_send(gps_uart->rx_stream, &data, 1, 0);
     furi_thread_flags_set(furi_thread_get_id(gps_uart->thread), WorkerEvtRxDone);
   }
 }
 
-static void gps_uart_serial_init(GpsUart* gps_uart) {
+static void gps_uart_serial_init(GpsUart* gps_uart)
+{
   furi_hal_console_disable();
   furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, gps_uart_on_irq_cb, gps_uart);
   furi_hal_uart_set_br(FuriHalUartIdUSART1, GPS_BAUDRATE);
 }
 
-static void gps_uart_serial_deinit(GpsUart* gps_uart) {
+static void gps_uart_serial_deinit(GpsUart* gps_uart)
+{
   UNUSED(gps_uart);
   furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, NULL, NULL);
   furi_hal_console_enable();
 }
 
-static void gps_uart_parse_nmea(GpsUart* gps_uart, char* line) {
+static void gps_uart_parse_nmea(GpsUart* gps_uart, char* line)
-    switch(minmea_sentence_id(line, false)) {
+{
-    case MINMEA_SENTENCE_RMC: {
+  switch (minmea_sentence_id(line, false))
+  {
+    case MINMEA_SENTENCE_RMC:
+    {
       struct minmea_sentence_rmc frame;
-        if(minmea_parse_rmc(&frame, line)) {
+      if (minmea_parse_rmc(&frame, line))
+      {
         gps_uart->status.valid = frame.valid;
         gps_uart->status.latitude = minmea_tocoord(&frame.latitude);
         gps_uart->status.longitude = minmea_tocoord(&frame.longitude);
         gps_uart->status.speed = minmea_tofloat(&frame.speed);
         gps_uart->status.course = minmea_tofloat(&frame.course);
+        gps_uart->status.time_hours = frame.time.hours;
+        gps_uart->status.time_minutes = frame.time.minutes;
+        gps_uart->status.time_seconds = frame.time.seconds;
+
+        notification_message_block(gps_uart->notifications, &sequence_blink_green_10);
       }
     } break;
 
-    case MINMEA_SENTENCE_GGA: {
+    case MINMEA_SENTENCE_GGA:
+    {
       struct minmea_sentence_gga frame;
-        if(minmea_parse_gga(&frame, line)) {
+      if (minmea_parse_gga(&frame, line))
+      {
         gps_uart->status.latitude = minmea_tocoord(&frame.latitude);
         gps_uart->status.longitude = minmea_tocoord(&frame.longitude);
         gps_uart->status.altitude = minmea_tofloat(&frame.altitude);
         gps_uart->status.altitude_units = frame.altitude_units;
         gps_uart->status.fix_quality = frame.fix_quality;
         gps_uart->status.satellites_tracked = frame.satellites_tracked;
+        gps_uart->status.time_hours = frame.time.hours;
+        gps_uart->status.time_minutes = frame.time.minutes;
+        gps_uart->status.time_seconds = frame.time.seconds;
+
+        notification_message_block(gps_uart->notifications, &sequence_blink_magenta_10);
       }
     } break;
 
@@ -61,7 +82,8 @@ static void gps_uart_parse_nmea(GpsUart* gps_uart, char* line) {
   }
 }
 
-static int32_t gps_uart_worker(void* context) {
+static int32_t gps_uart_worker(void* context)
+{
   GpsUart* gps_uart = (GpsUart*)context;
 
   gps_uart->rx_stream = furi_stream_buffer_alloc(RX_BUF_SIZE * 5, 1);
@@ -69,43 +91,51 @@ static int32_t gps_uart_worker(void* context) {
 
   gps_uart_serial_init(gps_uart);
 
-    while(1) {
+  while (1)
+  {
     uint32_t events =
     furi_thread_flags_wait(WORKER_ALL_RX_EVENTS, FuriFlagWaitAny, FuriWaitForever);
     furi_check((events & FuriFlagError) == 0);
 
-        if(events & WorkerEvtStop) {
+    if (events & WorkerEvtStop)
+    {
       break;
     }
     
-        if(events & WorkerEvtRxDone) {
+    if (events & WorkerEvtRxDone)
+    {
       size_t len = 0;
-            do {
+      do 
-                len = furi_stream_buffer_receive(
+      {
-                    gps_uart->rx_stream,
+        len = furi_stream_buffer_receive(gps_uart->rx_stream, gps_uart->rx_buf + rx_offset, RX_BUF_SIZE - 1 - rx_offset,
-                    gps_uart->rx_buf + rx_offset,
-                    RX_BUF_SIZE - 1 - rx_offset,
                                          0);
-                if(len > 0) {
+        if (len > 0)
+        {
           rx_offset += len;
           gps_uart->rx_buf[rx_offset] = '\0';
 
           char * line_current = (char *)gps_uart->rx_buf;
-                    while(1) {
+          while (1)
-                        while(*line_current == '\0' &&
+          {
-                              line_current < (char*)gps_uart->rx_buf + rx_offset - 1) {
+            while (*line_current == '\0' && line_current < (char *)gps_uart->rx_buf + rx_offset - 1)
+            {
               line_current++;
             }
 
             char * newline = strchr(line_current, '\n');
-                        if(newline) {
+            if (newline)
+            {
               *newline = '\0';
               gps_uart_parse_nmea(gps_uart, line_current);
               line_current = newline + 1;
-                        } else {
+            }
-                            if(line_current > (char*)gps_uart->rx_buf) {
+            else
+            {
+              if (line_current > (char *)gps_uart->rx_buf)
+              {
                 rx_offset = 0;
-                                while(*line_current) {
+                while (*line_current)
+                {
                   gps_uart->rx_buf[rx_offset++] = *(line_current++);
                 }
               }
@@ -113,7 +143,8 @@ static int32_t gps_uart_worker(void* context) {
             }
           }
         }
-            } while(len > 0);
+      }
+      while (len > 0);
     }
   }
 
@@ -123,7 +154,8 @@ static int32_t gps_uart_worker(void* context) {
   return 0;
 }
 
-GpsUart* gps_uart_enable() {
+GpsUart* gps_uart_enable()
+{
   GpsUart* gps_uart = malloc(sizeof(GpsUart));
 
   gps_uart->status.valid = false;
@@ -135,6 +167,11 @@ GpsUart* gps_uart_enable() {
   gps_uart->status.altitude_units = ' ';
   gps_uart->status.fix_quality = 0;
   gps_uart->status.satellites_tracked = 0;
+  gps_uart->status.time_hours = 0;
+  gps_uart->status.time_minutes = 0;
+  gps_uart->status.time_seconds = 0;
+
+  gps_uart->notifications = furi_record_open(RECORD_NOTIFICATION);
 
   gps_uart->thread = furi_thread_alloc();
   furi_thread_set_name(gps_uart->thread, "GpsUartWorker");
@@ -146,10 +183,14 @@ GpsUart* gps_uart_enable() {
   return gps_uart;
 }
 
-void gps_uart_disable(GpsUart* gps_uart) {
+void gps_uart_disable(GpsUart* gps_uart)
+{
   furi_assert(gps_uart);
   furi_thread_flags_set(furi_thread_get_id(gps_uart->thread), WorkerEvtStop);
   furi_thread_join(gps_uart->thread);
   furi_thread_free(gps_uart->thread);
+
+  furi_record_close(RECORD_NOTIFICATION);
+
   free(gps_uart);
 }

applications/plugins/gps_nmea_uart/gps_uart.h

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <furi_hal.h>
+#include <notification/notification_messages.h>
 
 #define GPS_BAUDRATE 9600
 #define RX_BUF_SIZE 1024
 
-typedef struct {
+typedef struct
+{
   bool valid;
   float latitude;
   float longitude;
@@ -15,13 +17,19 @@ typedef struct {
   char altitude_units;
   int fix_quality;
   int satellites_tracked;
+  int time_hours;
+  int time_minutes;
+  int time_seconds;
 } GpsStatus;
 
-typedef struct {
+typedef struct
+{
   FuriThread* thread;
   FuriStreamBuffer* rx_stream;
   uint8_t rx_buf[RX_BUF_SIZE];
 
+  NotificationApp* notifications;
+
   GpsStatus status;
 } GpsUart;
 

applications/plugins/gps_nmea_uart/minmea.c

@@ -14,30 +14,39 @@
 
 #define boolstr(s) ((s) ? "true" : "false")
 
-static int hex2int(char c) {
+static int hex2int(char c)
-    if(c >= '0' && c <= '9') return c - '0';
+{
-    if(c >= 'A' && c <= 'F') return c - 'A' + 10;
+    if (c >= '0' && c <= '9')
-    if(c >= 'a' && c <= 'f') return c - 'a' + 10;
+        return c - '0';
+    if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
     return -1;
 }
 
-uint8_t minmea_checksum(const char* sentence) {
+uint8_t minmea_checksum(const char *sentence)
+{
     // Support senteces with or without the starting dollar sign.
-    if(*sentence == '$') sentence++;
+    if (*sentence == '$')
+        sentence++;
 
     uint8_t checksum = 0x00;
 
     // The optional checksum is an XOR of all bytes between "$" and "*".
-    while(*sentence && *sentence != '*') checksum ^= *sentence++;
+    while (*sentence && *sentence != '*')
+        checksum ^= *sentence++;
 
     return checksum;
 }
 
-bool minmea_check(const char* sentence, bool strict) {
+bool minmea_check(const char *sentence, bool strict)
+{
     uint8_t checksum = 0x00;
 
     // A valid sentence starts with "$".
-    if(*sentence++ != '$') return false;
+    if (*sentence++ != '$')
+        return false;
 
     // The optional checksum is an XOR of all bytes between "$" and "*".
     while (*sentence && *sentence != '*' && isprint((unsigned char) *sentence))
@@ -48,13 +57,16 @@ bool minmea_check(const char* sentence, bool strict) {
         // Extract checksum.
         sentence++;
         int upper = hex2int(*sentence++);
-        if(upper == -1) return false;
+        if (upper == -1)
+            return false;
         int lower = hex2int(*sentence++);
-        if(lower == -1) return false;
+        if (lower == -1)
+            return false;
         int expected = upper << 4 | lower;
 
         // Check for checksum mismatch.
-        if(checksum != expected) return false;
+        if (checksum != expected)
+            return false;
     } else if (strict) {
         // Discard non-checksummed frames in strict mode.
         return false;
@@ -72,11 +84,13 @@ bool minmea_check(const char* sentence, bool strict) {
     return true;
 }
 
-bool minmea_scan(const char* sentence, const char* format, ...) {
+bool minmea_scan(const char *sentence, const char *format, ...)
+{
     bool result = false;
     bool optional = false;
 
-    if(sentence == NULL) return false;
+    if (sentence == NULL)
+        return false;
 
     va_list ap;
     va_start(ap, format);
@@ -85,7 +99,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
 #define next_field() \
     do { \
         /* Progress to the next field. */ \
-        while(minmea_isfield(*sentence)) sentence++; \
+        while (minmea_isfield(*sentence)) \
+            sentence++; \
         /* Make sure there is a field there. */ \
         if (*sentence == ',') { \
             sentence++; \
@@ -113,7 +128,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
             case 'c': { // Single character field (char).
                 char value = '\0';
 
-            if(field && minmea_isfield(*field)) value = *field;
+                if (field && minmea_isfield(*field))
+                    value = *field;
 
                 *va_arg(ap, char *) = value;
             } break;
@@ -152,7 +168,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                             sign = -1;
                         } else if (isdigit((unsigned char) *field)) {
                             int digit = *field - '0';
-                        if(value == -1) value = 0;
+                            if (value == -1)
+                                value = 0;
                             if (value > (INT_LEAST32_MAX-digit) / 10) {
                                 /* we ran out of bits, what do we do? */
                                 if (scale) {
@@ -164,13 +181,15 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                                 }
                             }
                             value = (10 * value) + digit;
-                        if(scale) scale *= 10;
+                            if (scale)
+                                scale *= 10;
                         } else if (*field == '.' && scale == 0) {
                             scale = 1;
                         } else if (*field == ' ') {
                             /* Allow spaces at the start of the field. Not NMEA
                              * conformant, but some modules do this. */
-                        if(sign != 0 || value != -1 || scale != 0) goto parse_error;
+                            if (sign != 0 || value != -1 || scale != 0)
+                                goto parse_error;
                         } else {
                             goto parse_error;
                         }
@@ -178,7 +197,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                     }
                 }
 
-            if((sign || scale) && value == -1) goto parse_error;
+                if ((sign || scale) && value == -1)
+                    goto parse_error;
 
                 if (value == -1) {
                     /* No digits were scanned. */
@@ -188,7 +208,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                     /* No decimal point. */
                     scale = 1;
                 }
-            if(sign) value *= sign;
+                if (sign)
+                    value *= sign;
 
                 *va_arg(ap, struct minmea_float *) = (struct minmea_float) {value, scale};
             } break;
@@ -199,7 +220,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                 if (field) {
                     char *endptr;
                     value = strtol(field, &endptr, 10);
-                if(minmea_isfield(*endptr)) goto parse_error;
+                    if (minmea_isfield(*endptr))
+                        goto parse_error;
                 }
 
                 *va_arg(ap, int *) = value;
@@ -209,7 +231,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                 char *buf = va_arg(ap, char *);
 
                 if (field) {
-                while(minmea_isfield(*field)) *buf++ = *field++;
+                    while (minmea_isfield(*field))
+                        *buf++ = *field++;
                 }
 
                 *buf = '\0';
@@ -217,11 +240,14 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
 
             case 't': { // NMEA talker+sentence identifier (char *).
                 // This field is always mandatory.
-            if(!field) goto parse_error;
+                if (!field)
+                    goto parse_error;
 
-            if(field[0] != '$') goto parse_error;
+                if (field[0] != '$')
+                    goto parse_error;
                 for (int f=0; f<5; f++)
-                if(!minmea_isfield(field[1 + f])) goto parse_error;
+                    if (!minmea_isfield(field[1+f]))
+                        goto parse_error;
 
                 char *buf = va_arg(ap, char *);
                 memcpy(buf, field+1, 5);
@@ -236,7 +262,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                 if (field && minmea_isfield(*field)) {
                     // Always six digits.
                     for (int f=0; f<6; f++)
-                    if(!isdigit((unsigned char)field[f])) goto parse_error;
+                        if (!isdigit((unsigned char) field[f]))
+                            goto parse_error;
 
                     char dArr[] = {field[0], field[1], '\0'};
                     char mArr[] = {field[2], field[3], '\0'};
@@ -259,7 +286,8 @@ bool minmea_scan(const char* sentence, const char* format, ...) {
                 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;
+                        if (!isdigit((unsigned char) field[f]))
+                            goto parse_error;
 
                     char hArr[] = {field[0], field[1], '\0'};
                     char iArr[] = {field[2], field[3], '\0'};
@@ -307,9 +335,11 @@ parse_error:
     return result;
 }
 
-bool minmea_talker_id(char talker[3], const char* sentence) {
+bool minmea_talker_id(char talker[3], const char *sentence)
+{
     char type[6];
-    if(!minmea_scan(sentence, "t", type)) return false;
+    if (!minmea_scan(sentence, "t", type))
+        return false;
 
     talker[0] = type[0];
     talker[1] = type[1];
@@ -318,31 +348,42 @@ bool minmea_talker_id(char talker[3], const char* sentence) {
     return true;
 }
 
-enum minmea_sentence_id minmea_sentence_id(const char* sentence, bool strict) {
+enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict)
-    if(!minmea_check(sentence, strict)) return MINMEA_INVALID;
+{
+    if (!minmea_check(sentence, strict))
+        return MINMEA_INVALID;
 
     char type[6];
-    if(!minmea_scan(sentence, "t", type)) return MINMEA_INVALID;
+    if (!minmea_scan(sentence, "t", type))
+        return MINMEA_INVALID;
 
-    if(!strcmp(type + 2, "GBS")) return MINMEA_SENTENCE_GBS;
+    if (!strcmp(type+2, "GBS"))
-    if(!strcmp(type + 2, "GGA")) return MINMEA_SENTENCE_GGA;
+        return MINMEA_SENTENCE_GBS;
-    if(!strcmp(type + 2, "GLL")) return MINMEA_SENTENCE_GLL;
+    if (!strcmp(type+2, "GGA"))
-    if(!strcmp(type + 2, "GSA")) return MINMEA_SENTENCE_GSA;
+        return MINMEA_SENTENCE_GGA;
-    if(!strcmp(type + 2, "GST")) return MINMEA_SENTENCE_GST;
+    if (!strcmp(type+2, "GLL"))
-    if(!strcmp(type + 2, "GSV")) return MINMEA_SENTENCE_GSV;
+        return MINMEA_SENTENCE_GLL;
-    if(!strcmp(type + 2, "RMC")) return MINMEA_SENTENCE_RMC;
+    if (!strcmp(type+2, "GSA"))
-    if(!strcmp(type + 2, "VTG")) return MINMEA_SENTENCE_VTG;
+        return MINMEA_SENTENCE_GSA;
-    if(!strcmp(type + 2, "ZDA")) return MINMEA_SENTENCE_ZDA;
+    if (!strcmp(type+2, "GST"))
+        return MINMEA_SENTENCE_GST;
+    if (!strcmp(type+2, "GSV"))
+        return MINMEA_SENTENCE_GSV;
+    if (!strcmp(type+2, "RMC"))
+        return MINMEA_SENTENCE_RMC;
+    if (!strcmp(type+2, "VTG"))
+        return MINMEA_SENTENCE_VTG;
+    if (!strcmp(type+2, "ZDA"))
+        return MINMEA_SENTENCE_ZDA;
 
     return MINMEA_UNKNOWN;
 }
 
-bool minmea_parse_gbs(struct minmea_sentence_gbs* frame, const char* sentence) {
+bool minmea_parse_gbs(struct minmea_sentence_gbs *frame, const char *sentence)
+{
     // $GNGBS,170556.00,3.0,2.9,8.3,,,,*5C
     char type[6];
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "tTfffifff",
-           sentence,
-           "tTfffifff",
             type,
             &frame->time,
             &frame->err_latitude,
@@ -351,37 +392,36 @@ bool minmea_parse_gbs(struct minmea_sentence_gbs* frame, const char* sentence) {
             &frame->svid,
             &frame->prob,
             &frame->bias,
-           &frame->stddev))
+            &frame->stddev
+            ))
+        return false;
+    if (strcmp(type+2, "GBS"))
         return false;
-    if(strcmp(type + 2, "GBS")) return false;
 
     return true;
 }
 
-bool minmea_parse_rmc(struct minmea_sentence_rmc* frame, const char* sentence) {
+bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence)
+{
     // $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
     char type[6];
     char validity;
     int latitude_direction;
     int longitude_direction;
     int variation_direction;
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "tTcfdfdffDfd",
-           sentence,
-           "tTcfdfdffDfd",
             type,
             &frame->time,
             &validity,
-           &frame->latitude,
+            &frame->latitude, &latitude_direction,
-           &latitude_direction,
+            &frame->longitude, &longitude_direction,
-           &frame->longitude,
-           &longitude_direction,
             &frame->speed,
             &frame->course,
             &frame->date,
-           &frame->variation,
+            &frame->variation, &variation_direction))
-           &variation_direction))
+        return false;
+    if (strcmp(type+2, "RMC"))
         return false;
-    if(strcmp(type + 2, "RMC")) return false;
 
     frame->valid = (validity == 'A');
     frame->latitude.value *= latitude_direction;
@@ -391,31 +431,27 @@ bool minmea_parse_rmc(struct minmea_sentence_rmc* frame, const char* sentence) {
     return true;
 }
 
-bool minmea_parse_gga(struct minmea_sentence_gga* frame, const char* sentence) {
+bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence)
+{
     // $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47
     char type[6];
     int latitude_direction;
     int longitude_direction;
 
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "tTfdfdiiffcfcf_",
-           sentence,
-           "tTfdfdiiffcfcf_",
             type,
             &frame->time,
-           &frame->latitude,
+            &frame->latitude, &latitude_direction,
-           &latitude_direction,
+            &frame->longitude, &longitude_direction,
-           &frame->longitude,
-           &longitude_direction,
             &frame->fix_quality,
             &frame->satellites_tracked,
             &frame->hdop,
-           &frame->altitude,
+            &frame->altitude, &frame->altitude_units,
-           &frame->altitude_units,
+            &frame->height, &frame->height_units,
-           &frame->height,
-           &frame->height_units,
             &frame->dgps_age))
         return false;
-    if(strcmp(type + 2, "GGA")) return false;
+    if (strcmp(type+2, "GGA"))
+        return false;
 
     frame->latitude.value *= latitude_direction;
     frame->longitude.value *= longitude_direction;
@@ -423,13 +459,12 @@ bool minmea_parse_gga(struct minmea_sentence_gga* frame, const char* sentence) {
     return true;
 }
 
-bool minmea_parse_gsa(struct minmea_sentence_gsa* frame, const char* sentence) {
+bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence)
+{
     // $GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39
     char type[6];
 
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "tciiiiiiiiiiiiifff",
-           sentence,
-           "tciiiiiiiiiiiiifff",
             type,
             &frame->mode,
             &frame->fix_type,
@@ -449,30 +484,29 @@ bool minmea_parse_gsa(struct minmea_sentence_gsa* frame, const char* sentence) {
             &frame->hdop,
             &frame->vdop))
         return false;
-    if(strcmp(type + 2, "GSA")) return false;
+    if (strcmp(type+2, "GSA"))
+        return false;
 
     return true;
 }
 
-bool minmea_parse_gll(struct minmea_sentence_gll* frame, const char* sentence) {
+bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence)
+{
     // $GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41$;
     char type[6];
     int latitude_direction;
     int longitude_direction;
 
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "tfdfdTc;c",
-           sentence,
-           "tfdfdTc;c",
             type,
-           &frame->latitude,
+            &frame->latitude, &latitude_direction,
-           &latitude_direction,
+            &frame->longitude, &longitude_direction,
-           &frame->longitude,
-           &longitude_direction,
             &frame->time,
             &frame->status,
             &frame->mode))
         return false;
-    if(strcmp(type + 2, "GLL")) return false;
+    if (strcmp(type+2, "GLL"))
+        return false;
 
     frame->latitude.value *= latitude_direction;
     frame->longitude.value *= longitude_direction;
@@ -480,13 +514,12 @@ 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) {
+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(
+    if (!minmea_scan(sentence, "tTfffffff",
-           sentence,
-           "tTfffffff",
             type,
             &frame->time,
             &frame->rms_deviation,
@@ -497,12 +530,14 @@ bool minmea_parse_gst(struct minmea_sentence_gst* frame, const char* sentence) {
             &frame->longitude_error_deviation,
             &frame->altitude_error_deviation))
         return false;
-    if(strcmp(type + 2, "GST")) return false;
+    if (strcmp(type+2, "GST"))
+        return false;
 
     return true;
 }
 
-bool minmea_parse_gsv(struct minmea_sentence_gsv* frame, const char* sentence) {
+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
     // $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D
     // $GPGSV,4,2,11,08,51,203,30,09,45,215,28*75
@@ -510,9 +545,7 @@ bool minmea_parse_gsv(struct minmea_sentence_gsv* frame, const char* sentence) {
     // $GPGSV,4,4,13*7B
     char type[6];
 
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "tiii;iiiiiiiiiiiiiiii",
-           sentence,
-           "tiii;iiiiiiiiiiiiiiii",
             type,
             &frame->total_msgs,
             &frame->msg_nr,
@@ -532,15 +565,18 @@ bool minmea_parse_gsv(struct minmea_sentence_gsv* frame, const char* sentence) {
             &frame->sats[3].nr,
             &frame->sats[3].elevation,
             &frame->sats[3].azimuth,
-           &frame->sats[3].snr)) {
+            &frame->sats[3].snr
+            )) {
         return false;
     }
-    if(strcmp(type + 2, "GSV")) return false;
+    if (strcmp(type+2, "GSV"))
+        return false;
 
     return true;
 }
 
-bool minmea_parse_vtg(struct minmea_sentence_vtg* frame, const char* sentence) {
+bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence)
+{
     // $GPVTG,054.7,T,034.4,M,005.5,N,010.2,K*48
     // $GPVTG,156.1,T,140.9,M,0.0,N,0.0,K*41
     // $GPVTG,096.5,T,083.5,M,0.0,N,0.0,K,D*22
@@ -548,9 +584,7 @@ bool minmea_parse_vtg(struct minmea_sentence_vtg* frame, const char* sentence) {
     char type[6];
     char c_true, c_magnetic, c_knots, c_kph, c_faa_mode;
 
-    if(!minmea_scan(
+    if (!minmea_scan(sentence, "t;fcfcfcfcc",
-           sentence,
-           "t;fcfcfcfcc",
             type,
             &frame->true_track_degrees,
             &c_true,
@@ -562,24 +596,28 @@ bool minmea_parse_vtg(struct minmea_sentence_vtg* frame, const char* sentence) {
             &c_kph,
             &c_faa_mode))
         return false;
-    if(strcmp(type + 2, "VTG")) return false;
+    if (strcmp(type+2, "VTG"))
+        return false;
     // values are only valid with the accompanying characters
-    if(c_true != 'T') frame->true_track_degrees.scale = 0;
+    if (c_true != 'T')
-    if(c_magnetic != 'M') frame->magnetic_track_degrees.scale = 0;
+        frame->true_track_degrees.scale = 0;
-    if(c_knots != 'N') frame->speed_knots.scale = 0;
+    if (c_magnetic != 'M')
-    if(c_kph != 'K') frame->speed_kph.scale = 0;
+        frame->magnetic_track_degrees.scale = 0;
+    if (c_knots != 'N')
+        frame->speed_knots.scale = 0;
+    if (c_kph != 'K')
+        frame->speed_kph.scale = 0;
     frame->faa_mode = (enum minmea_faa_mode)c_faa_mode;
 
     return true;
 }
 
-bool minmea_parse_zda(struct minmea_sentence_zda* frame, const char* sentence) {
+bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence)
+{
   // $GPZDA,201530.00,04,07,2002,00,00*60
   char type[6];
 
-    if(!minmea_scan(
+  if(!minmea_scan(sentence, "tTiiiii",
-           sentence,
-           "tTiiiii",
           type,
           &frame->time,
           &frame->date.day,
@@ -588,20 +626,22 @@ bool minmea_parse_zda(struct minmea_sentence_zda* frame, const char* sentence) {
           &frame->hour_offset,
           &frame->minute_offset))
       return false;
-    if(strcmp(type + 2, "ZDA")) return false;
+  if (strcmp(type+2, "ZDA"))
+      return false;
 
   // check offsets
-    if(abs(frame->hour_offset) > 13 || frame->minute_offset > 59 || frame->minute_offset < 0)
+  if (abs(frame->hour_offset) > 13 ||
+      frame->minute_offset > 59 ||
+      frame->minute_offset < 0)
       return false;
 
   return true;
 }
 
-int minmea_getdatetime(
+int minmea_getdatetime(struct tm *tm, const struct minmea_date *date, const struct minmea_time *time_)
-    struct tm* tm,
+{
-    const struct minmea_date* date,
+    if (date->year == -1 || time_->hours == -1)
-    const struct minmea_time* time_) {
+        return -1;
-    if(date->year == -1 || time_->hours == -1) return -1;
 
     memset(tm, 0, sizeof(*tm));
     if (date->year < 80) {
@@ -620,12 +660,11 @@ int minmea_getdatetime(
     return 0;
 }
 
-int minmea_gettime(
+int minmea_gettime(struct timespec *ts, const struct minmea_date *date, const struct minmea_time *time_)
-    struct timespec* ts,
+{
-    const struct minmea_date* date,
-    const struct minmea_time* time_) {
     struct tm tm;
-    if(minmea_getdatetime(&tm, date, time_)) return -1;
+    if (minmea_getdatetime(&tm, date, time_))
+        return -1;
 
     time_t timestamp = mktime(&tm); /* See README.md if your system lacks timegm(). */
     if (timestamp != (time_t)-1) {

applications/plugins/gps_nmea_uart/minmea.h

@@ -87,10 +87,8 @@ struct minmea_sentence_gga {
     int fix_quality;
     int satellites_tracked;
     struct minmea_float hdop;
-    struct minmea_float altitude;
+    struct minmea_float altitude; char altitude_units;
-    char altitude_units;
+    struct minmea_float height; char height_units;
-    struct minmea_float height;
-    char height_units;
     struct minmea_float dgps_age;
 };
 
@@ -230,28 +228,24 @@ bool minmea_parse_zda(struct minmea_sentence_zda* frame, const char* sentence);
 /**
  * Convert GPS UTC date/time representation to a UNIX calendar time.
  */
-int minmea_getdatetime(
+int minmea_getdatetime(struct tm *tm, const struct minmea_date *date, const struct minmea_time *time_);
-    struct tm* tm,
-    const struct minmea_date* date,
-    const struct minmea_time* time_);
 
 /**
  * Convert GPS UTC date/time representation to a UNIX timestamp.
  */
-int minmea_gettime(
+int minmea_gettime(struct timespec *ts, const struct minmea_date *date, const struct minmea_time *time_);
-    struct timespec* ts,
-    const struct minmea_date* date,
-    const struct minmea_time* time_);
 
 /**
  * Rescale a fixed-point value to a different scale. Rounds towards zero.
  */
-static inline int_least32_t minmea_rescale(const struct minmea_float* f, int_least32_t new_scale) {
+static inline int_least32_t minmea_rescale(const struct minmea_float *f, int_least32_t new_scale)
-    if(f->scale == 0) return 0;
+{
-    if(f->scale == new_scale) return f->value;
+    if (f->scale == 0)
+        return 0;
+    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) /
+        return (f->value + ((f->value > 0) - (f->value < 0)) * f->scale/new_scale/2) / (f->scale/new_scale);
-               (f->scale / new_scale);
     else
         return f->value * (new_scale/f->scale);
 }
@@ -260,8 +254,10 @@ static inline int_least32_t minmea_rescale(const struct minmea_float* f, int_lea
  * Convert a fixed-point value to a floating-point value.
  * Returns NaN for "unknown" values.
  */
-static inline float minmea_tofloat(const struct minmea_float* f) {
+static inline float minmea_tofloat(const struct minmea_float *f)
-    if(f->scale == 0) return NAN;
+{
+    if (f->scale == 0)
+        return NAN;
     return (float) f->value / (float) f->scale;
 }
 
@@ -269,10 +265,14 @@ static inline float minmea_tofloat(const struct minmea_float* f) {
  * Convert a raw coordinate to a floating point DD.DDD... value.
  * Returns NaN for "unknown" values.
  */
-static inline float minmea_tocoord(const struct minmea_float* f) {
+static inline float minmea_tocoord(const struct minmea_float *f)
-    if(f->scale == 0) return NAN;
+{
-    if(f->scale > (INT_LEAST32_MAX / 100)) return NAN;
+    if (f->scale == 0)
-    if(f->scale < (INT_LEAST32_MIN / 100)) return NAN;
+        return NAN;
+    if (f->scale  > (INT_LEAST32_MAX / 100))
+        return NAN;
+    if (f->scale < (INT_LEAST32_MIN / 100))
+        return NAN;
     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);