3(3)

NAME
libgps - C service library for communicating with the GPS daemon

SYNOPSIS

C:
#include <gps.h>

int gps_open(char *server, char * port, struct gps_data_t *gpsdata);

int gps_send(struct gps_data_t *gpsdata, char *fmt...);

int gps_read(struct gps_data_t *gpsdata);

bool gps_waiting(struct gps_data_t *gpsdata, int timeout);

void gps_data(struct gps_data_t *gpsdata);

void gps_close(struct gps_data_t *gpsdata);

int gps_stream(struct gps_data_t *gpsdata, unsigned intflags, void *data);

const char *gps_errstr(int err);

Python:
import gps
session = gps.gps(host="localhost", port="2947")
session.stream(flags=WATCH_JSON)
for report in session:
    process(report)
del session

DESCRIPTION

libgps is a service library which supports communicating with an instance of the gpsd(8); link it with the linker option -lgps.

    Warning

    Take care to conditionalize your code on the major and minor API version symbols in gps.h; ideally, force a compilation failure if GPSD_API_MAJOR_VERSION is not a version you recognize. See the GPSD project website for more information on the protocol and API changes.

Calling gps_open() initializes a GPS-data structure to hold the data collected by the GPS, and returns a socket attached to gpsd(1). gps_open() returns 0 on success, -1 on errors and is re-entrant. errno is set depending on the error returned from the socket layer; see gps.h for values and explanations; also see gps_errstr(). The host address may be a DNS name, an IPv4 dotted quad, or an IPV6 address; the library will do the right thing for any of these.

gps_close() ends the session.

gps_send() writes a command to the daemon. The second argument must be a format string containing elements from the command set documented at gpsd(1). It may have % elements as for sprintf(3), which will be filled in from any following arguments. This function returns a -1 if there was a Unix-level write error, otherwise 0. Please read the LIMITATIONS section for additional information and cautions. See gps_stream() as a possible alternative.

gps_read() accepts a response, or sequence of responses, from the daemon and interprets it as though it were a query response (the return value is as for a query). This function does a nonblocking read for data from the daemon; it returns a count of bytes read for success, -1 with errno set on a Unix-level read error, -1 with errno not set if the socket to the daemon has closed, and 0 if no data is available.

gps_waiting() can be used to check whether there is data from the daemon. The second argument is the maximum amount of time to wait (in microseconds) on input before returning. It returns true if there input waiting, false on timeout (no data waiting) or error condition. This function is a convenience wrapper around a select(2) call, and zeros errno on entry; you can test errno after exit to get more information about error conditions. Note that choosing a wait timeout of less than twice the cycle time of your device will be hazardous, as the receiver probably will not supply input often enough to prevent a spurious error indication. For the typical 1-second cycle time of GPSes this implies a minimum 2-second timeout.

gps_data() returns the contents of the client data buffer. Use with care; this may fail to be a NUL-terminated string if WATCH_RAW is enabled.

gps_stream() asks gpsd to stream the reports it has at you, to be made available when you poll. It is preferable to the older-style (pre-2.90) way of doing this, gps_query() with a "w+" argument, because it insulates your code from whether your client library and your gpsd are using old or new protocol. The second argument is a flag mask that sets various policy bits; see the list below. Calling gps_stream() more than once with different flag masks is allowed.

WATCH_DISABLE
    Disable the reporting modes specified by the other WATCH_ flags.

WATCH_ENABLE
    Disable the reporting modes specified by the other WATCH_ flags. This is the default.

WATCH_JSON
    Enable JSON reporting of data. If WATCH_ENABLE is set, and no other WATCH flags are set, this is the default.

WATCH_NMEA
    Enable generated pseudo-NMEA reporting on binary devices.

WATCH_RARE
    Enable reporting of binary packets in encoded hex.

WATCH_RAW
    Enable literal passthrough of binary packets.

WATCH_SCALED
    When reporting AIS or Subframe data, scale integer quantities to floats if they have a divisor or rendering formula associated with them.

WATCH_NEWSTYLE
    Force issuing a JSON initialization and getting new-style responses. This is the default.

WATCH_OLDSTYLE
    Force issuing a W or R command and getting old-style responses. Warning: this flag (and the capability) will be removed in a future release.

WATCH_DEVICE
    Restrict watching to a specified device, patch given as second argument.

gps_errstr() returns an ASCII string (in English) describing the error indicated by a nonzero return value from gps_open().

Consult gps.h to learn more about the data members and associated timestamps. Note that information will accumulate in the session structure over time, and the 'valid' field is not automatically zeroed by each gps_read(). It is up to the client to zero that field when appropriate and to keep an eye on the fix and sentence timestamps.

The Python implementation supports the same facilities as the C library. gps_open() is replaced by the initialization of a gps session object; the other calls are methods of that object, and have the same names as the corresponding C functions. However, it is simpler just to use the session object as an iterator, as in the example given below. Resources within the session object will be properly released when it is garbage-collected.

CODE EXAMPLE

The following is an excerpted and simplified version of the libgps interface code from cgps(1).

        struct gps_data_t gps_data;
        ret = gps_open(hostName, hostPort, &gps_data);
        (void) gps_stream(&gps_data, WATCH_ENABLE | WATCH_JSON, NULL);
        /* Put this in a loop with a call to a high resolution sleep () in it. */
        if (gps_waiting (&gps_data, 500)) {
            errno = 0;
            if (gps_read (&gps_data) == -1) {
                ...
            } else {
                /* Display data from the GPS receiver. */
                if (gps_data.set & ...
            }
        }
        /* When you are done... */
        (void) gps_stream(&gps_data, WATCH_DISABLE, NULL);
        (void) gps_close (&gps_data);

LIMITATIONS

In the C API, incautious use of gps_send() may lead to subtle bugs. In order to not bloat struct gps_data_t with space used by responses that are not expected to be shipped in close sequence with each other, the storage for fields associated with certain responses are combined in a union.

The risky set of responses includes VERSION, DEVICELIST, RTCM2, RTCM3, SUBFRAME, AIS, GST, and ERROR; it may not be limited to that set. The logic of the daemon's watcher mode is careful to avoid dangerous sequences, but you should read and understand the layout of struct gps_data_t before using gps_send() to request any of these responses.

COMPATIBILITY

The gps_query() supported in major versions 1 and 2 of this library has been removed. With the new streaming-oriented wire protocol behind this library, it is extremely unwise to assume that the first transmission from the daemon after a command is shipped to it will be the response to command.

If you must send commands to the daemon explicitly, use gps_send() but beware that this ties your code to the GPSD wire protocol. It is not recommended.

In earlier versions of the API gps_read() was a blocking call and there was a POLL_NONBLOCK option to make it nonblocking. gps_waiting() was added to reduce the number of wrong ways to code a polling loop.

See the comment above the symbol GPSD_API_MAJOR_VERSION in gps.h for recent changes.

SEE ALSO

gpsd(8), gps(1), libgpsd(3). libgpsmm(3).

AUTHOR

Eric S. Raymond <esr@thyrsus.com>, C sample code Charles Curley <charlescurley@charlescurley.com>