Need help with libnmea?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

154 Stars 61 Forks MIT License 219 Commits 13 Opened issues


Lightweight C library for parsing NMEA 0183 sentences

Services available


Need anything else?

Contributors list

C Library for Parsing NMEA 0183 Sentences

Build Status Memory Leaks License

Libnmea is a lightweight C library that parses NMEA 0183 sentence strings into structs. It is written in a modular architecture that dynamically loads a parser module for each implemented sentence type. This way, new sentences can easily be added to the library without modifying the core code. It is also possible to statically link the parser modules at build time to enable libnmea to be used in environments where a dynamic loader isn't available.

If you find any sentence missing, please add it by contributing to the code. I am open to suggestions regarding the code and architecture, so if you have any ideas or improvements, please tell me or submit a merge request :-).

Supported sentences:

, and

To build

$ make && make check

When running

, the library will be built to a local build directory (./build).



make install
to install libnmea. The files will be installed in /usr/ by default. Use the environment variable
to set a different installation prefix.

Ex. to build and install the library and header files locally, in the ./target directory, run the following commands:

$ make
$ PREFIX=target make install

Try it

When the library is built and installed, you can compile the example programs:

$ make examples
$ echo -ne "\$GPGLL,4916.45,N,12311.12,W,225444,A,*1D\r\n" | build/parse_stdin

If the library was installed with a custom prefix, you may have to set the following environment variables before running

export LIBRARY_PATH="/lib"
export C_INCLUDE_PATH="/include"
export LD_LIBRARY_PATH="/lib"

Additionally, set

variable before running the program:
export NMEA_PARSER_PATH="/lib/nmea/"
Note that the trailing slash is required!

How to use it

First, include nmea.h and the header files for the desired sentence types:


#include <nmea.h> #include #include

int main(void) { /* ... */ return 0; } </nmea.h></string.h></stdio.h></stdlib.h>

To parse an NMEA sentence string, use

// Sentence string to be parsed
char sentence[] = "$GPGLL,4916.45,N,12311.12,W,225444,A,*1D\r\n";

// Pointer to struct containing the parsed data nmea_s *data;

// Parse it... data = nmea_parse(sentence, strlen(sentence), 0); if (NULL == data) { exit(EXIT_FAILURE); }

The parsed data can be found in the data variable and for example printed to screen:

if (NMEA_GPGGA == data->type) {
    nmea_gpgga_s *gpgga = (nmea_gpgga_s *) data;

printf("GPGGA Sentence\n");
printf("Number of satellites: %d\n", gpgga-&gt;n_satellites);
printf("Altitude: %d %c\n", gpgga-&gt;altitude, gpgga-&gt;altitude_unit);


if (NMEA_GPGLL == data->type) { nmea_gpgll_s *gpgll = (nmea_gpgll_s *) data;

printf("GPGLL Sentence\n");
printf("  Degrees: %d\n", gpgll-&gt;longitude.degrees);
printf("  Minutes: %f\n", gpgll-&gt;longitude.minutes);
printf("  Cardinal: %c\n", (char) gpgll-&gt;longitude.cardinal);
printf("  Degrees: %d\n", gpgll-&gt;latitude.degrees);
printf("  Minutes: %f\n", gpgll-&gt;latitude.minutes);
printf("  Cardinal: %c\n", (char) gpgll-&gt;latitude.cardinal);


Free the memory used by the data variable:


Compile with

$ gcc example.c -lnmea -o example

Environment variables

Run time:

- The path where the parser libraries are located. Default is
. If a custom prefix was used when installing, they will be located in PREFIX/lib/nmea. This variable isn't used when libnmea is built with static parser module loading (see next chapter).

Build time:

- If defined, it forces libnmea to be built with static parser module loading (see next chapter). It should contain a comma seperated list of parser modules to be included in the build, ex:

Static build

It is possible to statically link the parser modules at build time which is useful when a dynamic loader isn't available. To do this, the environment variable

must be defined along with a comma-seperated list of selected parser modules to include in the library. Note that both dynamic and static module loading cannot be utilized at the same time.

Run tests


, run the tests against the build directory:
$ make check

To run the unit tests against the installation directory, run the following command:

$ make unit-tests

To check for memory leaks, run:

$ make check-memory-leaks

Library functions

Check nmea.h for more detailed info about functions. The header files for the sentences (ex: nmea/gpgll.h) contains the struct definitions for each sentence.

Implement a new sentence type

To create a new sentence parser, create the following files and replace the

 with the sentence type word in uppercase letters and 
lowercase. Make sure that the sentence type is defined in src/nmea.h and add
it to src/nmea/parser_static.h.


#ifndef INC_NMEA__H
#define INC_NMEA__H

#include <stdlib.h> #include <string.h> #include <time.h> #include <nmea.h>

typedef struct { nmea_s base; /* sentence values */ } nmea__s;

/* Value indexes / #define NMEA__ 0 / more value indexes... */

#endif /* INC_NMEA__H */ </nmea.h></time.h></string.h></stdlib.h>


#include "../nmea/parser_types.h"
#include ".h"
#include "parse.h"

int init(nmea_parser_s parser) { / Declare what sentence type to parse */ NMEA_PARSER_TYPE(parser, NMEA_); NMEA_PARSER_PREFIX(parser, ""); return 0; }

int allocate_data(nmea_parser_s *parser) { parser->data = malloc(sizeof (nmea__s)); return 0; }

int set_default(nmea_parser_s *parser) { memset(parser->data, 0, sizeof (nmea__s)); return 0; }

int free_data(nmea_s *data) { free(data); return 0; }

int parse(nmea_parser_s *parser, char *value, int val_index) { nmea_gpgll_s *data = (nmea__s *) parser->data;

switch (val_index) {
case NMEA_<type>_<index>:
    /* Parse some value */
    data-&gt;some_value = value;


return 0;



Contributions are more than welcome. Be sure to read this chapter before submitting a merge request.

Coding style

The code should conform to the KNF formatting guidelines.


$ indent -st -bad -bap -bbb -bc -blf -bli0 -br -brs -bs -cbi0 -ce -cli0 -cs -nbfda -npcs -nprs -nsob -saf -saw -sai src/nmea/nmea.c

Use hard tabs. Example vim options:

:set noexpandtab
:set preserveindent
:set softtabstop=0
:set shiftwidth=4
:set tabstop=4


Every merge request must pass all the tests.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.