|Project Name||Stars||Downloads||Repos Using This||Packages Using This||Most Recent Commit||Total Releases||Latest Release||Open Issues||License||Language|
|Androbd||989||6 days ago||63||gpl-3.0||Java|
|Android OBD diagnostics with any ELM327 adapter|
|Pygpsclient||224||17 hours ago||67||May 23, 2022||3||bsd-3-clause||Python|
|Python Graphical GPS Client Application supporting NMEA, UBX, RTCM3, NTRIP & SPARTN Protocols|
|A NMEA parser and GPS utility library|
|Seaglass||142||6 years ago||1||bsd-3-clause||Python|
|Ardupilotblue||112||2 years ago||12||gpl-3.0|
|Howto use BeagleBone Blue with ArduPilot|
|Rn2483 Arduino Library||82||10 months ago||19||apache-2.0||C++|
|Arduino C++ code to communicate with a Microchip RN2483 module|
|Gps Neo 6m||46||a year ago||5||C++|
|GPS Library Arduino, NMEA|
|Vx8_gps||44||a month ago||mit||C|
|DIY GPS module for Yaesu VX-8DR/VX-8DE handheld transceiver.|
|Gpstutorial||43||4 months ago||1||C++|
|A simple tutorial for troubleshooting GPSs on Arduino|
|Tlazserial||42||5 months ago||4||Pascal|
|Serial Port Component for Lazarus (windows and linux).|
Current Status | Features | How to Use | UBX Configuration | NTRIP Client | SPARTN Client | Socket Server / NTRIP Caster | GPX Track Viewer | Installation | Mapquest API Key | User-defined Presets | CLI Utilities | License | Author Information
PyGPSClient is a multi-platform graphical GNSS/GPS testing, diagnostic and UBX © (u-blox ™) device configuration application written entirely in Python and tkinter.
Screenshot showing mixed-protocol stream from u-blox ZED-F9P receiver, using PyGPSClient's NTRIP Client to achieve >= 3cm accuracy
While not intended to be a direct replacement, the application supports much of the UBX configuration functionality in u-blox's Windows-only u-center © tool.
The application can be installed using the standard
pip Python package manager - see installation instructions below.
The PyGPSClient home page is at PyGPSClient GUI. For a general overview of GNSS, DGPS, RTK, NTRIP and SPARTN technologies and terminology, refer to GNSS Positioning - A Reviser.
Sphinx API Documentation in HTML format is available at https://www.semuconsulting.com/pygpsclient.
Contributions welcome - please refer to CONTRIBUTING.MD.
Bug reports and Feature requests - please use the templates provided. For general queries and advice, post a message to one of the PyGPSClient Discussions channels.
This is an independent project and we have no affiliation whatsoever with u-blox.
Rate bps(baud rate) is typically the only setting that might need adjusting, but tweaking the
timeoutsetting may improve performance on certain platforms. The
Msg Modeparameter defaults to
GETi.e., periodic or poll response messages from a receiver. If you wish to parse streams of command or poll messages being sent to a receiver, set the
PYGPSCLIENT_USERPORTor as a command line argument
*.log, *.ubx, *.*) and path. PyGPSClient datalog files will be named e.g.
pygpsdata-20220427114802.log, but any binary dump of an GNSS receiver output is acceptable, including
*.ubxfiles produced by u-center.
The UBX Configuration Dialog currently supports the following UBX configuration panels:
Msg Modein the Settings panel to
SETrather than the default
An icon to the right of each 'SEND' button indicates the confirmation status of the configuration command; (pending i.e. awaiting confirmation , confirmed or warning ).
The NTRIP Configuration utility allows users to receive and process NTRIP RTK Correction data from an NTRIP caster to achieve cm level location accuracy. The facility can be accessed by clicking or selecting Menu..Options..NTRIP Configuration Dialog.
PyGPSClientwill automatically identify the closest mountpoint to the current location.
Below is a illustrative NTRIP DGPS data log, showing:
NB: Please respect the terms and conditions of any remote NTRIP service used with this facility. For testing or evaluation purposes, consider deploying a local SNIP LITE server. Inappropriate use of an NTRIP service may result in your account being blocked.
The SPARTN Configuration utility allows users to receive and process SPARTN RTK Correction data from an IP or L-Band source to achieve cm level location accuracy. It provides three independent configuration sections, one for IP Correction (MQTT), one for L-Band Correction (e.g. D9S) and a third for the GNSS receiver (e.g. F9P).
NB: the SPARTN client utilises a new
pyspartn library. The
pyspartn.SPARTNReader class will parse individual SPARTN messages from any binary stream containing solely SPARTN data e.g. an MQTT
/pp/ip topic. The
pyspartn.SPARTNMessage class is in Alpha and does not currently perform a full decode of SPARTN protocol messages; it basically decodes just enough information to identify message type/subtype, payload length and other key metadata.
The facility can be accessed by clicking or selecting Menu..Options..NTRIP Configuration Dialog.
IP Correction (MQTT Client):
*.crt) and key (
*.pem) files. If these are placed in the user's HOME directory using the location service's standard naming convention, PyGPSClient will find them automatically.
/pp/ip/region(binary SPARTN correction data for the selected region),
/pp/ubx/mga(UBX MGA AssistNow ephemera data for each constellation) and
/pp/ubx/0236/ip(UBX RXM-SPARTNKEY messages containing the decryption keys to be uploaded to the GNSS receiver).
L-BAND Correction (D9* Receiver):
The SPARTN client configuration can be loaded from a JSON file provided by the Location Service provider (e.g. u-blox / Thingstream) by clicking
Load Keys from JSON. If the JSON file is valid, the Client ID, MQTT Server URL, Current and Next decryption keys and Valid from dates will be entered automatically.
*.pemfiles provided by the location service (PyGPSClient will use the user's HOME directory by default).
RXM-PMPmessages) will be automatically passed through to the GNSS receiver by PyGPSClient, without the need to connect the two externally.
0102030405060708090a0b0c0d0e0f10. The keys are normally 16 bytes long, or 32 hexadecimal characters.
YYYYMMDDformat. NB: These are Valid From dates rather than Expiry dates. If the location service provides Expiry dates, subtract 4 weeks from these to get the Valid From dates.
/pp/ubx/0236/ip) topic, the key and date details will be entered automatically on receipt of a UBX RXM-SPARTNKEY message (which may take a few seconds after connecting). Alternatively, they can be uploaded from a JSON file.
Below is a illustrative SPARTN DGPS data log, showing:
The Socket Server / NTRIP Caster facility is capable of operating in either of two modes;
gnssdump(CLI utility installed with
pygnssutils) running on another machine. In this mode it will broadcast the host's currently connected GNSS data stream (NMEA, UBX, RTCM3). The default port is 50010.
gnssntripclient(CLI utility installed with
pygnssutils). Login credentials for the NTRIP caster are set via host environment variables
PYGPSCLIENT_PASSWORD. The default port is 2101.
Running in NTRIP caster mode is predicated on the host being connected to an RTK-compatible GNSS receiver operating in Base Station mode (either
FIXED) and outputting the requisite RTCM3 message types (1005, 1077, 1087, 1097, 1127 and 1230). In the case of the u-blox ZED-F9P receiver, for example, this is set using the
CFG-MSGOUT-RTCM* configuration interface parameters available via the UBX Configuration panel - refer to the Integration Manual and Interface Specification for further details. PyGPSClient does not configure the receiver automatically, though an example configuration script for the u-blox ZED-F9P receiver may be found at /examples/f9p_basestation.py. This script can also be used to generate user-defined preset command strings suitable for copying and pasting into a
ubxpresets file (see User Defined Presets below).
The server/caster binds to the host address '0.0.0.0' i.e. all available IP addresses on the host machine. It may be necessary to add a firewall rule on the host and/or client machine to allow remote traffic on the specified port.
A label on the settings panel indicates the number of connected clients, and the server/caster status is indicated in the topmost banner: open with no clients: , open with clients: .
GPX Track Viewer screenshot
The GPX Track Viewer can display any valid GPX file containing trackpoints (
<trkpt>..</trkpt> elements). The map display requires a free MapQuest API key. The Y axis scales will reflect the current choice of units (metric or imperial). Click to refresh the display after any changes (e.g. resizing, zooming or change of units).
In the following,
pip refer to the Python 3 executables. You may need to type
pip3, depending on your particular environment. It is also recommended that
the Python 3 scripts (bin) and site_packages directories are included in your PATH
(many standard Python 3 installation packages will do this automatically).
On Windows and MacOS, pip, tkinter and the necessary imaging libraries are generally packaged with Python 3. On some Linux distributions like Ubuntu 18+ and Raspberry Pi OS, they may need to be installed separately, e.g.:
sudo apt install python3-pip python3-tk python3-pil python3-pil.imagetk
NB: If you're compiling the latest version of Python 3 from source, you may also need to install tk-dev (or a similarly named package e.g. tk-devel) first. Refer to http://wiki.python.org/moin/TkInter for further details.
sudo apt install tk-dev
Ideally the platform screen resolution will be at least 1400 x 900, though the main application window is resizeable.
To access the serial port on most Linux platforms, you will need to be a member of the
dialout groups. Other than this, no special privileges are required.
usermod -a -G tty myuser
The easiest way to install the latest version of
PyGPSClient is with
python3 -m pip install --upgrade pygpsclient
PyGPSClient can also be installed into a virtual environment, e.g.:
python3 -m pip install --user --upgrade virtualenv python3 -m virtualenv env source env/bin/activate (or env\Scripts\activate on Windows) (env) python3 -m pip install --upgrade pygpsclient ... deactivate
To run the application, if the Python 3 scripts (bin) directory is in your PATH, simply type (all lowercase):
pygpsclient also accepts optional command line arguments for user ports, MapQuest API key and MQTT Client ID. Type the following for help:
If desired, you can add a shortcut to this command to your desktop or favourites menu.
Alternatively, if the Python 3 site_packages are in your PATH, you can type (all lowercase):
python3 -m pygpsclient
NB: If the Python 3 scripts (bin) or site_packages directories are not in your PATH, you will need to add the fully-qualified path to
pygpsclient in the commands above.
Tip: to find the site_packages location, type:
python3 -m pip show pygpsclient
and look for the
Location: entry in the response, e.g.
Tip: To create an application launcher for linux distributions like Ubuntu, create a text file named
pygpsclient.desktop with the following content (edited for your particular environment) and copy this to the
/home/user/.local/share/applications folder, e.g.
[Desktop Entry] Type=Application Terminal=false Name=PyGPSClient --mqttclientid lkaasdfjsdh-flkj-adhs-lkfj-hjhfdsf --mqapikey asjkdhflakdshflkjasdhfgsjfyfgiuy Icon=/home/user/.local/lib/python3.11/site-packages/pygpsclient/resources/pygpsclient.ico Exec=/home/user/.local/bin/pygpsclient
The following Python libraries are required (these will be installed automatically if using pip to install PyGPSClient):
python3 -m pip install --upgrade pygnssutils pyserial Pillow requests pyspartn
To install PyGPSClient manually, download and unzip this repository and run:
python3 -m /path_to_folder/foldername/pygpsclient
e.g. if you downloaded and unzipped to a folder named
python3 -m /path_to_folder/PyGPSClient-1.3.20/pygpsclient
To use the optional dynamic web-based mapview or GPX Track Viewer facilities, you need to request and install a free MapQuest API key (no payment details required). The free edition of this API allows for up to 15,000 transactions/month (roughly 500/day) on a non-commercial basis. For this reason, the map refresh rate is intentionally limited to 1/minute* to avoid exceeding the free transaction limit under normal use. NB: this facility is not intended to be used for real time navigational purposes.
Once you have received the API key (a 32-character alphanumeric string), you can either:
MQAPIKEY(all upper case) and set this to the API key value. It is recommended that this is a User variable rather than a System/Global variable.
mqapikey(lower case, no extension) and place this file in the user's home directory.
*The web map refresh rate can be amended if required by changing the MAP_UPDATE_INTERVAL constant in
The UBX Configuration Dialog includes the facility to send user-defined UBX configuration messages or message sequences to the receiver. These can be set up by adding
appropriate comma-delimited message descriptions and payload definitions to a file named
ubxpresets (lower case, no extension), and then placing this file in the user's home directory. The message definition comprises a free-format text description (avoid embedded commas)
followed by one or more pyubx2 UBXMessage constructors, i.e.
CFG(must be a valid class from pyubx2.UBX_CLASSES)
CFG-MSG(must be a valid id from pyubx2.UBX_MSGIDS)
f004010100010100(leave blank for null payloads e.g. most POLL messages)
(payload as hex string can be obtained from a
UBXMessage created using the pyubx2 library thus:
Multiple commands can be concatenated on a single line. Illustrative examples are shown below:
Stop GNSS, CFG, CFG-RST, 00000800, 1 Start GNSS, CFG, CFG-RST, 00000900, 1 Enable NMEA UBX00 & UBX03 sentences, CFG, CFG-MSG, f100010100010100, 1, CFG, CFG-MSG, f103010100010100, 1 Poll NEO-9 UART1/2 baud rates, CFG, CFG-VALGET, 000000000100524001005340, 2 Poll NEO-9 Message Rates, CFG, CFG-VALGET, 00000000ffff9120, 2, CFG, CFG-VALGET, 00004000ffff9120, 2, CFG, CFG-VALGET, 00008000ffff9120, 2 Set ZED-F9P to Base Station Survey-In Mode (1m accuracy), CFG, CFG-VALSET, 000100008b00912001c002912001cf02912001d4029120011b03912001d902912001060391200111000340e8030000100003405a0000000100032001, 1 Set ZED-F9P to Base Station Survey-In Mode (1cm accuracy), CFG, CFG-VALSET, 000100008b00912001c002912001cf02912001d4029120011b03912001d9029120010603912001110003400a000000100003405a0000000100032001, 1 Poll Receiver Software Version, MON, MON-VER, , 2 Poll Datum, CFG, CFG-DAT, , 2 Poll GNSS config, CFG, CFG-GNSS, , 2 Poll NMEA config, CFG, CFG-NMEA, , 2 Poll Satellite-based Augmentation, CFG, CFG-SBAS, , 2 Poll Receiver Management, CFG, CFG-RXM, , 2 Poll Navigation Mode, CFG, CFG-NAV5, , 2 Poll Expert Navigation mode, CFG, CFG-NAVX5, , 2 Poll Geofencing, CFG, CFG-GEOFENCE, , 2 Poll Timepulse, CFG, CFG-TP5, , 2 Set NEO-M8T Timepulse to 1 Hz, CFG, CFG-TP5, 000100003200000001000000010000003200000032000000000000006f000000, 1 Set NEO-M8T Timepulse to 8 MHz, CFG, CFG-TP5, 000100003200000000127a0000127a003200000032000000000000006f000000, 1 Limit NMEA GNSS to GPS only, CFG, CFG-NMEA, 0040000276000000000000010000000000000000, 1 Limit NMEA GNSS to GLONASS only, CFG, CFG-NMEA, 0040000257000000000000010000000000000000, 1 Set NMEA GNSS to ALL, CFG, CFG-NMEA, 0040000200000000000000010000000000000000, 1 Limit UBX GNSS to GPS only, CFG, CFG-GNSS, 0020200700081000010001010101030000000101020408000000010103081000000001010400080000000103050003000000010506080E0000000101, 1 Limit UBX GNSS to GLONASS only, CFG, CFG-GNSS, 0020200700081000000001010101030000000101020408000000010103081000000001010400080000000103050003000000010506080E0001000101, 1 Set UBX GNSS to ALL, CFG, CFG-GNSS, 0020200700081000010001010101030001000101020408000000010103081000000001010400080000000103050003000100010506080E0001000101, 1 FORCE COLD RESTART !*** Expect ClearCommError ***!, CFG, CFG-RST, ffff0100, 1
pygnssutils library which underpins many of the functions in
PyGPSClient also incorporates command line versions of these functions:
gnssdumpCLI utility. This is essentially a configurable input/output wrapper around the
pyubx2.UBXReaderclass with flexible message formatting and filtering options for NMEA, UBX and RTCM3 protocols.
gnssserverCLI utility. This implements a TCP Socket Server for GNSS data streams which is also capable of being run as a simple NTRIP Server.
gnssntripclientCLI utility. This implements a simple NTRIP Client which receives RTCM3 correction data from an NTRIP Server and (optionally) sends this to a designated output stream.
gnssmqttclientCLI utility. This implements a simple SPARTN IP (MQTT) Client which receives SPARTN and UBX correction data from a SPARTN IP location service (e.g. u-blox / Thingstream PointPerfect) and (optionally) sends this to a designated output stream.
ubxsaveCLI utility. This saves a complete set of configuration data from any Generation 9+ u-blox device (e.g. NEO-M9N or ZED-F9P) to a file. The file can then be reloaded to any compatible device using the
ubxloadCLI utility. This reads a file containing binary configuration data and loads it into any compatible Generation 9+ u-blox device (e.g. NEO-M9N or ZED-F9P).
ubxsetrateCLI utility. A simple utility which sets NMEA or UBX message rates on u-blox GNSS receivers.
For further details, refer to the
pygnssutils homepage at semuconsulting/pygnssutils.
BSD 3-Clause License
Copyright © 2020, SEMU Consulting All rights reserved.
Application icons from iconmonstr ©.
PyGPSClient is maintained entirely by unpaid volunteers. It receives no funding from advertising or corporate sponsorship. If you find the utility useful, a small donation would be greatly appreciated!