Code Quality Rank: L2
Monthly Downloads: 13
Programming language: Rust
License: GNU Lesser General Public License v3.0 only
Tags: Network    
Latest version: v3.4.4

sbp alternatives and similar packages

Based on the "Networking" category.
Alternatively, view sbp alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of sbp or a related project?

Add another 'Networking' Package


Specification and Bindings for Swift Binary Protocol

Build status

<!-- toc -->

<!-- tocstop -->

The Swift Navigation Binary Protocol (SBP) is a fast, simple, and minimal binary protocol for communicating with Swift devices. It is the native binary protocol used by the Piksi GPS receiver to transmit solutions, observations, status and debugging messages, as well as receive messages from the host operating system, such as differential corrections and the almanac.

This project provides language-agnostic specification and documentation for messages used with SBP, a compiler for generating message bindings, and client libraries in a variety of languages. This repository is organized into the following directory structure:

  • [docs](./docs): Protocol documentation and message definitions.
  • [spec](./spec): Machine readable protocol specification in YAML.
  • [generator](./generator): Simple, template-based generator for different languages.
  • [python](./python): Python client and examples.
  • [c](./c): C client library and examples.
  • [haskell](./haskell): Haskell client and examples.
  • [java](./java): Java client library and examples.
  • [javascript](./javascript): JavaScript client library and examples.
  • [rust](./rust): Rust client library and examples.
  • [sbpjson](./sbpjson): Tools for parsing SBP-JSON.

Except for the generator, all of the above are generated and should not be modified directly.

This repository also provides the following utilities for comprehending and inspecting SBP data:

  • sbp2json: converts SBP binary into a JSON representation, in which field names and values are expanded into JSON objects, common fields such as "message type" and "payload" are included as well.

  • json2sbp: uses the "message type", "payload" and related fields from an SBP JSON stream to reconstruct the binary representation.

  • json2json: some tools (notably the Swift GUI Console) produce abbreviated JSON logs with only common fields such as "message type" and "payload", the json2json tool expands these JSON objects to include fields specific the individual message.

To install a released version of these tools, visit the releases page and download an archive for your platform.

To install from source, you can use Rust's cargo tool (first install Rust), then run:

cargo install --git https://github.com/swift-nav/libsbp.git --bins

There's also a [Haskell version](./haskell) available which can be installed by running stack install in the [./haskell](./haskell) directory of a checkout of this repo (after installing stack) or by visiting the releases by and downloading an sbp_tools_haskell archive. This variant of the tools predate the Rust and Python versions, and also includes an sbp2yaml tool as well as a sbp2prettyjson tool.

Finally, a Python version of the sbp2json tool exists, which is installable on any platform that supports Python via pip, e.g.:

pip3 install sbp

The tool can then be invoked as follows:

python3 -m sbp2json <sbp.bin

On select platforms this Python tool is accelerated with native code and has performance on par with the Haskell and Rust variants.

Building / installing

Using Docker

Fetching the prebuilt image from DockerHub

The quickest method to get going is to just pull a prebuilt copy from DockerHub (no guarantees on freshness):

docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2020.09.15

Check this link for newer tags.

Creating your own image

Otherwise, Dockerfile-build will create a docker image that contains all the necessary dependencies to build libsbp. You can make a local image fresh from this file by running docker build as such:

mkdir docker-build; cd docker-build

This dummy directory is to prevent docker from sucking up the whole repo into the local context (which is then immediately discarded anyway). Next create the docker image:

docker build -f ../Dockerfile-build -t libsbp-build .

You can then make this image operate on your local workspace like this:

cd .. (back up to the root of the repo)

docker run -v $PWD:/mnt/workspace -i -t libsbp-build:latest

Using the docker image

Once in the image, simply type make all to gererate all the libsbp bindings.

Installing from package managers

Some bindings are available on package managers:

Installing development Python versions

To install the Python binding from source (using pip) run the following command:

pip install 'file:///path/to/libsbp#subdirectory=python'

Or via setuptools directly:

cd /path/to/libsbp
cd python
python setup.py

Adding development version as a pip dependency

Run the following command:

pip install git+https://github.com/swift-nav/[email protected]<GIT_REVISION>#egg=sbp&subdirectory=python

Or add this to requirements.txt:

git+https://github.com/swift-nav/[email protected]<GIT_REVISION>#egg=sbp&subdirectory=python

Installing from source

You can build one binding at a time or update all at once:

make python


make all

are both valid. To see a list of all valid targets, run make help.

Python version notes:

  1. by default the Python targets make python and make test-python (as well as make all) run tests on all Python versions officially supported by the libsbp Python bindings, currently 2.7, 3.5, and 3.7, skipping any versions not installed. To run tests on just specific Python version(s), specify the TOXENV environment variable, e.g., TOXENV=py27,py35 make python. Travis runs Python tests on all supported versions.
  2. by default the code generators are run on the system's (or virtual env's) default Python interpreter. Currently Python versions 2.7, 3.5, and 3.7 are officially supported, other versions may or may not work. The generated libsbp bindings should be the same on all supported Python versions. To use a different version than your default Python interpreter, specify the GENENV environment variable, e.g., GENENV=py27 make all (you must have that version of Python installed beforehand).
  3. to run both the generator and the Python tests on specific Python versions, specify both envs, e.g., GENENV=py37 TOXENV=py27,py37 make python

SBP Protocol Specification

SBP consists of two pieces: (i) an over-the-wire message framing format and (ii) structured payload definitions. As of Version 1.0, the packet consists of a 6-byte binary header section, a variable-sized payload field, and a 16-bit CRC value. SBP uses the CCITT CRC16 (XMODEM implementation) for error detection.

Please see the docs for a full description of the packet structure and the message types. Developer documentatation for the language-specific sbp libraries is here. Please refer to the changelog for more information about the evolution of the library and its messages.

JSON Schema Definitions

For web clients processing SBP in JSON form, JSON schema definitions are provided. Libraries for JavaScript, TypeScript, and Elm generated by the QuickType tool are provided. See the HOWTO for instructions on updating these schemas.


Copyright © 2020 Swift Navigation

Distributed under MIT.

*Note that all licence references and agreements mentioned in the sbp README section above are relevant to that project's source code only.