NemaTode

Cross platform C++ 11 NMEA Parser & GPS Framework

NemaTode is yet another lightweight generic NMEA parser.

It also comes with a GPS data interface to handle the most popular GPS NMEA sentences.

Confirmed on MSVC 2013 and GCC 4.8.4.

It's too easy!

This is all you need to use the GPS NMEA sentence data.

NMEAParser parser;
GPSService gps(parser);
// (optional) Called when a sentence is valid syntax
parser.onSentence += [](const NMEASentence& nmea){
    cout << "Received $" << nmea.name << endl;
};
// (optional) Called when data is read/changed
gps.onUpdate += [](GPSService& gps){
    // There are *tons* of GPSFix properties
    if( gps.fix.locked() ){
        cout << " # Position: " << gps.fix.latitude << ", " << gps.fix.longitude << endl;
    } else {
        cout << " # Searching..." << endl;
    }
};
// Send in a log file or a byte stream
try {
    parser.readLine("FILL WITH A NMEA MESSAGE");
} catch (NMEAParseError&) {
    // Syntax error, skip
}

Features

NMEA Parsing of standard and custom sentences.
- Standard:
```
GPGGA, GPGSA, GPGSV, GPRMC, GPVTG
```
NMEA Generation of "standard" and custom sentences.
- SiRF Control sentences: PSRF100, PSRF103
GPS Fix class to manage and organize all the GPS related data.
Flexible
- Stream data directly from a hardware byte stream
- Read log files, even if they are cluttered with other unrelated data.
- Easily hook into the parser to handle custom sentences and get their data.
- Simplified GPS data
C++ 11 features
- Those fancy event handlers...
- If you are on an embedded system... sorry. This might not work for you because of compiler restrictions. Make sure there is full support for lambdas and variadic templates. Tested GCC 4.8.4, confirmed.

Details

NMEA is very popular with GPS. Unfortunately the GPS data is fragmented between many different NMEA sentences. Sometimes there is even conflicting information in them!

The underlying NMEAParser can read a byte stream from a hardware device or it can read log files with flexibility in the formatting. The accepted strings are...

"$[name:alphanum],[param[i]:alphanum],...(*alphanum[2]\r)\n"

The params allow '-' and any combination of whitespace.

The handler for "MYNMEA" is called. This is where you can catch the sentence and process it.

parser.setSentenceHandler("MYNMEA",[](const NMEASentence& nmea){
    if( ! nmea.checksumOK() ){
        // bad checksum, but valid syntax
    }
    if( nmea.parameters.size() < 3 ){
        // missing data, throw something.
        // catch it at the read*() call.
    }
    int mydata = parseInt(nmea.parameters[2]);
};

There are 2 ways to operate...

LAX It will eat anything.
- Useful for reading log files.
- Call readByte(), readBuffer(), readLine()
STRICT It will throw errors on anything that's not explicitly NMEA.
- Call readSentence()

Demos

"demo_simple.cpp"

Just reads the GPS position data.

"demo_advanced.cpp"

Reads all the data
Sentence Generation
Custom Sentence handling

Generation

NMEACommand mycmd;
mycmd.name = "MYCMD";
mycmd.message = "your,data,csv";
string nmea = mycmd.toString();  // Creates: $MYCMD,your,data,csv*15

There are 2 included NMEACommands that can configure a GPS.

PSRF103 Configures message output ID and rate, and whether or not to use checksums.
PSRF100 Configures the UART serial connection (if the chip has one).

Include NemaTode in your project

You can include NemaTode via CMake in our project. Your basic CMakeLists.txt file could look like:

cmake_minimum_required(VERSION 3.1)
project(MyProject)

find_package(NemaTode REQUIRED CONFIG)

add_executable(${PROJECT_NAME} mycode.cpp)

target_link_libraries(${PROJECT_NAME} NemaTode::NemaTode)

GPS Fix data available

Available data when all 5 GPS sentences are received. If some are missing then some parameters will never change from their default values. All data is checked for consistency. For example, visible satellites can never be less than the tracking satellites, etc.

GPSFix

GPSAlmanac     almanac;
GPSTimestamp    timestamp;

char        status;     // Status: A=active, V=void (not locked)
uint8_t     type;       // Type: 1=none, 2=2d, 3=3d
uint8_t     quality;    // Quality (1-6) 

double      dilution;       // Combination of Vertical & Horizontal
double      horizontalDilution; // Horizontal dilution of precision, initialized to 10, best =1, worst = >20
double      verticalDilution;   // Vertical is less accurate

double      altitude;       // meters
double      latitude;       // degrees N
double      longitude;      // degrees E
double      speed;          // km/h
double      travelAngle;        // degrees true north (0-359)
int32_t     trackingSatellites;
int32_t     visibleSatellites;

bool        locked();       // Whether or not the position is locked on, or accurate.
double      horizontalAccuracy();   // Gets accuracy of position in meters
double      verticalAccuracy();
bool        hasEstimate();      // If no fix is available, this says the position data is close to a real fix.

std::chrono::seconds timeSinceLastUpdate(); // Returns time from last timestamp to right now, in seconds.

GPSSatellite

double      snr;        // Signal-to-noise ratio. 0-99 dB
uint32_t    prn;        // pseudo-random number.  (basically a satellite id)
double      elevation;  // 0-90 deg
double      azimuth;    // 0-359 deg

GPSAlmanac

std::vector<GPSSatellite> satellites;   // mapped by prn (id number)
double      averageSNR(); 
double      minSNR();
double      maxSNR();
double      percentComplete();  // if all the satellite information is loaded (0-100)

GPSTimestamp (UTC Time)

int32_t     hour;       // Parsed values from GPS
int32_t     min;        
double      sec;        
int32_t     month;      
int32_t     day;        
int32_t     year;       
double      rawTime;    // Values collected directly from the GPS
int32_t     rawDate;    
time_t      getTime();  // Converts timestamp into Epoch time, seconds since 1/1/1970.

NemaTode?

NMEA -> ME -> EM -> NEMA

+Tode

ckgt / NemaTode

readme