#include <Arduino.h>
#include "NMEA.h"

NMEA nmea_parser; // Inicializa o $GNGGA,194134.00,2327.98767,S,05150.40168,W,1,10,0.82,564.4,M,0.1,M,,*77
int num_satellites = 0;

void setup() {
  Serial.begin(9600); // Inicia a comunicação serial
  Serial.println("Envie a sentença NMEA...");
}

void loop() {
  if (Serial.available()) { // Verifica se há dados disponíveis na entrada serial
    char c = Serial.read(); // Lê um caractere da entrada serial
    // Decodifica o caractere
    if (nmea_parser.decode(c)) {
      // Quando uma sentença completa é lida e decodificada
      Serial.println(nmea_parser.sentence()); // Mostra a sentença completa
      // Quando uma sentença completa é decodificada
      num_satellites = nmea_parser.gpgga_satellites(); // Obtém o número de satélites
      Serial.print("Número de Satélites: ");
      Serial.println(num_satellites);
    }
  }
}


main.cpp

diagram.json

#ifndef NMEA_h
#define NMEA_h

constexpr const int ALL = 0;                        // Connect to all datatypes
constexpr const int GPRMC = 1;                      // Connect only to GPRMC datatype
constexpr const float MTR = 1.0f;                   // Meters per meter
constexpr const float KM = 0.001f;                  // Kilometers per meter
constexpr const float MI = 0.00062137112f;          // Miles per meter
constexpr const float NM = 0.00053995680f;          // Nautical miles per meter
constexpr const float PARSEC = 0.0f;                // Parsecs per meter (approximation)
constexpr const float MPS = 0.51444444f;            // Meters-per-second in one knot
constexpr const float KMPH = 1.852f;                // Kilometers-per-hour in one knot
constexpr const float MPH = 1.1507794f;             // Miles-per-hour in one knot
constexpr const float KTS = 1.0f;                   // Knots in one knot
constexpr const float LIGHTSPEED = 0.000000001716f; // Lightspeeds in one knot

constexpr const char* _GPRMC_TERM = "$GPRMC,";
constexpr const char* _GNRMC_TERM = "$GNRMC,";
constexpr const char* _GPGGA_TERM = "$GPGGA,";
constexpr const char* _GNGGA_TERM = "$GNGGA,";

constexpr float NUM_PI = 3.1415926535897932384626433832795F;
constexpr float NUM_TWO_PI = 6.283185307179586476925286766559F;

#define RADIANS(deg) ((deg)*0.017453292519943295769236907684886F)
#define DEGREES(rad) ((rad)*57.295779513082320876798154814105F)
#define SQ(x) ((x)*(x))

class NMEA {
  public:
    explicit NMEA(); // Constructor for NMEA parser object; parse sentences of GPRMC or all datatypes.
    int decode(char c); // Parse one character received from GPS; returns 1 when full sentence found w/ checksum OK, 0 otherwise
    void parse_sentences(); // Get NMEA sentences
    void gprmc_process(); // Process GPRMC sentence
    void gpgga_process(); // Process GPGGA sentence
    int gpgga_satellites() const; // Returns number os satellites
    float gprmc_utc() const; // Returns decimal value of UTC term in last full GPRMC sentence
    char gprmc_status() const; // Returns status character in last full GPRMC sentence ('A' or 'V')
    float gprmc_latitude() const; // Signed degree-decimal value of latitude terms in last full GPRMC sentence
    float gprmc_longitude() const; // Signed degree-decimal value of longitude terms in last full GPRMC sentence
    float gprmc_speed(float unit) const; // Speed-on-ground term in last full GPRMC sentence
    float gprmc_course() const; // Track-angle-made-good term in last full GPRMC sentence
    float gprmc_distance_to(float latitude, float longitude, float unit) const; // Returns distance from last-known GPRMC position to given position
    float gprmc_course_to(float latitude, float longitude) const; // Returns initial course in degrees from last-known GPRMC position to given position
    char *sentence(); // Returns last received full sentence as zero terminated string
    int terms() const; // Returns number of terms (including data type and checksum) in last received full sentence
    char *term(int t) const; // Returns term t of last received full sentence as zero terminated string
    float term_decimal(int t) const; // Returns the base-10 converted value of term[t] in last full sentence received
  private:
    // Private properties
    float _gprmc_utc = 0.0;
    char _gprmc_status = 'V';
    float _gprmc_lat = 0.0;
    float _gprmc_long = 0.0;
    float _gprmc_speed = 0.0;
    float _gprmc_angle = 0.0;
    char f_sentence[100];
    char *f_term[30];
    int f_terms = 0;
    int _terms = 0;
    char _sentence[100];
    char *_term[30];
    float _degs = 0.0;
    int _gpgga_satellites = 0;
    int _gpgga_tag = 0;
    int _gprmc_tag = 0;
    int _state = 0;
    int _parity = 0;
    int _n = 0;
    int _nt = 0;
    // Private Methods
    float distance_between(float lat1, float long1, float lat2, float long2, float units_per_meter) const;
    float initial_course(float lat1, float long1, float lat2, float long2) const;
    int _dehex(char a) const;
    float _decimal(const char *s) const;
};

#endif


NMEA.h

#include "math.h"
#include "NMEA.h"

//
// Constructor method
//

NMEA::NMEA()
{
    // Allocate memory for individual terms of sentence
    for (int t = 0; t < 30; t++) {
        _term[t] = (char *)malloc(15 * sizeof(char));
        f_term[t] = (char *)malloc(15 * sizeof(char));
        (f_term[t])[0] = 0;
    }
}

//
// public methods
//

int NMEA::decode(char c)
{
    // Avoid runaway sentences (>99 chars or >29 terms) and terms (>14 chars)
    if ((_n >= 100) || (_terms >= 30) || (_nt >= 15)) {
        _state = 0;
    }

    // LF and CR always reset parser
    if ((c == 0x0A) || (c == 0x0D)) {
        _state = 0;
    }

    // '$' always starts a new sentence
    if (c == '$') {
        _gprmc_tag = 0;
        _gpgga_tag = 0;
        _parity = 0;
        _terms = 0;
        _nt = 0;
        _sentence[0] = c;
        _n = 1;
        _state = 1;
        return 0;
    }

    // Parse other chars according to parser state
    switch (_state) {
    case 0:
        // Waiting for '$', do nothing
        break;
    case 1:
        // Decode chars after '$' and before '*' found
        if (_n < 7) {
            // See if first seven chars match "$GPRMC," or "$GNRMC,"
            if ((c == _GNRMC_TERM[_n]) || (c == _GPRMC_TERM[_n])) {
                _gprmc_tag++;
            }

            if ((c == _GNGGA_TERM[_n]) || (c == _GPGGA_TERM[_n])) {
                _gpgga_tag++;
            }
        }

        // Add received char to sentence
        _sentence[_n++] = c;
        switch (c) {
        case ',':
            // ',' Delimits the individual terms
            (_term[_terms++])[_nt] = 0;
            _nt = 0;
            _parity = _parity ^ c;
            break;
        case '*':
            // '*' Delimits term and precedes checksum term
            (_term[_terms++])[_nt] = 0;
            _nt = 0;
            _state++;
            break;
        default:
            // All other chars between '$' and '*' are part of a term
            (_term[_terms])[_nt++] = c;
            _parity = _parity ^ c;
            break;
        }
        break;
    case 2:
        // First char following '*' is checksum MSB
        _sentence[_n++] = c;
        (_term[_terms])[_nt++] = c;
        _parity = _parity - (16 * _dehex(c)); // Replace with bitshift?
        _state++;
        break;
    case 3:
        // Second char after '*' completes the checksum (LSB)
        _sentence[_n++] = c;
        _sentence[_n++] = 0;

        (_term[_terms])[_nt++] = c;
        (_term[_terms++])[_nt] = 0;

        _state = 0;
        _parity = _parity - _dehex(c);

        // When parity is zero, checksum was correct!
        if (_parity != 0)
          return 0;

        parse_sentences();

        // When sentence is of datatype GPRMC
        if (_gprmc_tag == 6) {
            gprmc_process();
        }

        // When sentence is of datatype GPGGA
        if (_gpgga_tag == 6) {
            gpgga_process();
        }

        // Sentence accepted!
        return 1;

    default:
        _state = 0;
        break;
    }

    return 0;
}

void NMEA::parse_sentences()
{
    // Copy _sentence[] to f_sentence[]
    while ((--_n) >= 0) {
        f_sentence[_n] = _sentence[_n];
    }

    // Copy all _terms[] to f_terms[]
    for (f_terms = 0; f_terms < _terms; f_terms++) {
        _nt = 0;
        while ((_term[f_terms])[_nt]) {
            (f_term[f_terms])[_nt] = (_term[f_terms])[_nt];
            _nt++;
        }
        (f_term[f_terms])[_nt] = 0;
    }
}

void NMEA::gprmc_process()
{
    // Store values of relevant GPRMC terms
    _gprmc_utc = _decimal(_term[1]);
    _gprmc_status = (_term[2])[0];

    // Calculate signed degree-decimal value of latitude term
    _gprmc_lat = _decimal(_term[3]) / 100.0f;
    _degs = floor(_gprmc_lat);
    _gprmc_lat = (100.0f * (_gprmc_lat - _degs)) / 60.0f;
    _gprmc_lat += _degs;

    // Southern hemisphere is negative-valued
    if ((_term[4])[0] == 'S') {
        _gprmc_lat = 0.0f - _gprmc_lat;
    }

    // Calculate signed degree-decimal value of longitude term
    _gprmc_long = _decimal(_term[5]) / 100.0f;
    _degs = floor(_gprmc_long);
    _gprmc_long = (100.0f * (_gprmc_long - _degs)) / 60.0f;
    _gprmc_long += _degs;

    // Western hemisphere is negative-valued
    if ((_term[6])[0] == 'W') {
        _gprmc_long = 0.0f - _gprmc_long;
    }

    _gprmc_speed = _decimal(_term[7]);
    _gprmc_angle = _decimal(_term[8]);
}

void NMEA::gpgga_process()
{
    // Ensure that there are enough terms and the expected term is not empty
    if (_terms > 7 && _term[7][0] != '\0') {
        _gpgga_satellites = atoi(_term[7]); // Convert the number of satellites from string to int
    } else {
        // Handle the case where the satellite term is missing or empty
        _gpgga_satellites = 0;
    }
}

int NMEA::gpgga_satellites() const
{
    return _gpgga_satellites;
}

float NMEA::gprmc_utc() const
{
    // Returns decimal value of UTC term of last-known GPRMC sentence
    return _gprmc_utc;
}

char NMEA::gprmc_status() const
{
    // Returns status character of last-known GPRMC sentence ('A' or 'V')
    return _gprmc_status;
}

float NMEA::gprmc_latitude() const
{
    // Returns signed degree-decimal latitude value of last-known GPRMC position
    return _gprmc_lat;
}

float NMEA::gprmc_longitude() const
{
    // Returns signed degree-decimal longitude value of last-known GPRMC position
    return _gprmc_long;
}

float NMEA::gprmc_speed(float unit) const
{
    // Returns speed-over-ground from last-known GPRMC sentence
    return (_gprmc_speed * unit);
}

float NMEA::gprmc_course() const
{
    // Returns decimal value of track-angle-made-good term in last-known GPRMC sentence
    return _gprmc_angle;
}

float NMEA::gprmc_distance_to(float latitude, float longitude, float unit) const
{
    // Returns distance from last-known GPRMC position to given position
    return distance_between(_gprmc_lat, _gprmc_long, latitude, longitude, unit);
}

float NMEA::gprmc_course_to(float latitude, float longitude) const
{
    // Returns initial course in degrees from last-known GPRMC position to given position
    return initial_course(_gprmc_lat, _gprmc_long, latitude, longitude);
}

char *NMEA::sentence()
{
    // Returns last received full sentence as zero terminated string
    return f_sentence;
}

int NMEA::terms() const
{
    // Returns number of terms (including data type and checksum) in last received full sentence
    return f_terms;
}

char *NMEA::term(int t) const
{
    // Returns term t of last received full sentence as zero terminated string
    return f_term[t];
}

float NMEA::term_decimal(int t) const
{
    // Returns value of decimally coded term t
    return _decimal(f_term[t]);
}

//
// Private methods
//

float NMEA::distance_between(float lat1, float long1, float lat2, float long2, float units_per_meter) const
{
    // Returns distance in meters between two positions, both specified
    // as signed decimal-degrees latitude and longitude. Uses great-circle
    // distance computation for hypothised sphere of radius 6372795 meters.
    // Because Earth is no exact sphere, rounding errors may be upto 0.5%.
    float delta = RADIANS(long1 - long2);
    float sdlong = sin(delta);
    float cdlong = cos(delta);

    lat1 = RADIANS(lat1);
    lat2 = RADIANS(lat2);

    float slat1 = sin(lat1);
    float clat1 = cos(lat1);
    float slat2 = sin(lat2);
    float clat2 = cos(lat2);

    delta = (clat1 * slat2) - (slat1 * clat2 * cdlong);
    delta = SQ(delta);
    delta += SQ(clat2 * sdlong);
    delta = sqrt(delta);

    float denom = (slat1 * slat2) + (clat1 * clat2 * cdlong);

    delta = atan2(delta, denom);

    return delta * 6372795 * units_per_meter;
}

float NMEA::initial_course(float lat1, float long1, float lat2, float long2) const
{
    // Returns initial course in degrees (North=0, West=270) from
    // position 1 to position 2, both specified as signed decimal-degrees
    // latitude and longitude.
    float dlon = RADIANS(long2 - long1);

    lat1 = RADIANS(lat1);
    lat2 = RADIANS(lat2);

    float a1 = sin(dlon) * cos(lat2);
    float a2 = sin(lat1) * cos(lat2) * cos(dlon);

    a2 = cos(lat1) * sin(lat2) - a2;
    a2 = atan2(a1, a2);

    if (a2 < 0.0) {
        a2 += NUM_TWO_PI; // modulo operator doesn't seem to work on floats
    }

    return DEGREES(a2);
}

int NMEA::_dehex(char a) const
{
    // Returns base-16 value of chars '0'-'9' and 'A'-'F';
    // does not trap invalid chars!
    if (int(a) >= 65) {
        return int(a) - 55;
    } else {
        return int(a) - 48;
    }
}

float NMEA::_decimal(const char *s) const
{
    // Returns base-10 value of zero-termindated string
    // that contains only chars '+','-','0'-'9','.';
    // does not trap invalid strings!
    long rl = 0;
    float rr = 0.0;
    float rb = 0.1f;
    bool dec = false;
    int i = 0;

    if ((s[i] == '-') || (s[i] == '+'))
        i++;

    while (s[i] != 0) {
        if (s[i] == '.') {
            dec = true;
        } else {
            if (!dec) {
                rl = (10 * rl) + (s[i] - 48);
            } else {
                rr += rb * (float)(s[i] - 48);
                rb /= 10.0f;
            }
        }

        i++;
    }

    rr += (float)rl;

    if (s[0] == '-') {
        rr = 0.0f - rr;
    }

    return rr;
}
