Resurrection project • first public source release • 8 September 2026

libadsb-reader

Native Linux access to two classic ADS-B receivers that were never designed to live forever: the Kinetic SBS-1 and the AirNav RadarBox V1 / RB-1. No Windows application, no vendor SDK and no network bridge in between — just USB, reconstructed device protocols and a small common C API.

Why this exists

Old receivers. New Linux code.

The ACARSd Museum began as an archive of software, screenshots, reports and stories. In 2026 it became an active laboratory again. While restoring the old receiving setup, we wanted to use the original ADS-B hardware directly under Linux instead of treating it as a display piece.

The result is libadsb-reader: a clean-room/interoperability-oriented library built from observed USB communication and independently reconstructed device behaviour. The project currently supports the exact SBS-1 and RadarBox hardware tested in the Museum.

Kinetic SBS-1: the FT2232 USB protocol, startup exchange, packet framing, decryption and Mode-S extraction were reconstructed for native Linux use.

AirNav RadarBox V1 / RB-1: the FTDI/D2XX-style setup, challenge/response unlock and proprietary sample stream were reconstructed, including demodulation into 56- and 112-bit Mode-S frames.

One API: both receivers now feed the same raw-frame and decoded-message callbacks.

Hardware support

What the library talks to

Kinetic SBS-1

USB 0403:6010 · FT2232

  • Native libusb access
  • Reconstructed startup challenge/response
  • SBS packet framing and decryption
  • Packet CRC verification
  • Mode-S extraction from packet types 0x01 and 0x07

Tested with the Museum's original SBS-1 hardware.

AirNav RadarBox V1 / RB-1

USB 0403:bb80 · FTDI

  • Native libusb access
  • FTDI/D2XX-style device setup
  • Reconstructed RadarBox challenge/response unlock
  • Proprietary 56/112-bit sample-stream demodulation
  • Mode-S CRC filtering

Tested with RadarBox V1 / RB-1. Other RadarBox generations are not claimed as supported.

The included command-line tool

adsb-reader

The source tree includes adsb-reader, a small CLI built on the same public library API. It is useful for hardware tests, piping raw Mode-S into other software and as a working example of how to integrate the library.

# Discover supported receivers currently attached
./adsb-reader --list

# Automatically choose a supported receiver
./adsb-reader --device auto

# Explicit receiver selection
./adsb-reader --device radarbox
./adsb-reader --device sbs1

# Conventional AVR raw output
./adsb-reader --device radarbox --avr

AVR mode emits conventional lines such as:

*8D4D22AC58AF16AB9FF9107EB3D3;
Build & install

Building on Debian / Ubuntu

sudo apt install build-essential pkg-config libusb-1.0-0-dev libsqlite3-dev libcurl4-openssl-dev

tar xzf libadsb-reader-0.1.16.tar.gz
cd libadsb-reader-0.1.16
make
sudo make install
sudo ldconfig

After installation, pkg-config can provide compiler and linker flags to applications:

pkg-config --cflags --libs libadsb-reader
pkg-config --modversion libadsb-reader

The expected version for this release is 0.1.16.

C API

Using libadsb-reader in your own program

The normal lifecycle is deliberately short: create a configuration, open a reader, register one or both callbacks, run the blocking receive loop, then close it. adsb_reader_stop() can be called from a signal handler or another control path to request shutdown.

#include <adsb-reader/adsb_reader.h>

char err[256];
adsb_reader_config_t cfg = {0};
cfg.device = ADSB_DEVICE_AUTO;

adsb_reader_t *r = adsb_reader_open(
    &cfg, err, sizeof(err));
if (!r) {
    /* handle err */
}

adsb_reader_set_raw_callback(r, raw_cb, NULL);
adsb_reader_set_message_callback(r, msg_cb, NULL);

adsb_reader_run(r);
adsb_reader_close(r);

Two callback levels

Raw callback
adsb_raw_frame_t exposes the original 7- or 14-byte Mode-S frame, DF, ICAO address, timestamp and transport CRC state.

Decoded callback
adsb_message_t exposes decoded and accumulated fields through valid_fields and updated_fields.

This lets an application choose between handling Mode-S itself or using the common decoder.

Decoded fields currently exposed

Field flagData
ADSB_FIELD_CALLSIGNADS-B callsign
ADSB_FIELD_ALTITUDEBarometric altitude in feet
ADSB_FIELD_SPEEDGround speed in knots
ADSB_FIELD_HEADINGTrack / heading in degrees
ADSB_FIELD_POSITIONGlobal airborne CPR latitude / longitude
ADSB_FIELD_SQUAWKMode A squawk, including 7500 / 7600 / 7700 when transmitted
ADSB_FIELD_REGISTRATIONOptional resolver registration
ADSB_FIELD_AIRCRAFT_TYPEOptional resolver aircraft type
ADSB_FIELD_FLIGHT_ROUTEOptional origin / destination codes
ADSB_FIELD_AIRCRAFT_OPERATOROptional aircraft operator information
ADSB_FIELD_FLIGHT_AIRLINEOptional flight airline information
ADSB_FIELD_ORIGIN_AIRPORTOptional origin airport name and coordinates
ADSB_FIELD_DESTINATION_AIRPORTOptional destination airport name and coordinates
Optional Museum resolver

Aircraft, flight and route enrichment

The core receiver and decoder do not require a network connection. Applications may optionally enable the ACARSd Museum resolver/collector with resolve_unknowns or the CLI option --resolve. Resolver data are cached locally in SQLite so USB reception is never blocked by HTTP.

./adsb-reader --device radarbox \
  --resolve \
  --location 46.8300,17.8300

The first resolver use requires a receiver location. It may be numeric coordinates or a text location such as Budapest. The location is persisted in the resolver database.

Privacy / network note. Resolver mode contributes one snapshot per aircraft contact to the ACARSd collector. A contact remains active until that ICAO24 has not been seen for 15 minutes. If you only want local decoding, simply do not enable --resolve.

Default local resolver database:

root:        /var/lib/libadsb-reader/resolver.db
normal user: $XDG_DATA_HOME/libadsb-reader/resolver.db
             or ~/.local/share/libadsb-reader/resolver.db
0.1.16 engineering notes

What changed in this release

  • RadarBox asynchronous USB shutdown is hardened: outstanding libusb transfers are cancelled and drained before teardown on every receive-loop exit.
  • Persistent contact de-duplication is separated from resolver completeness, allowing missing aircraft or flight data to be resolved later during the same encounter.
  • A callsign received after the first contact snapshot can trigger a later flight lookup.
  • RadarBox collector snapshots prefer DF17/DF18 Extended Squitter frames when available.
  • Version metadata is synchronized across the public header, Makefile, CMake and pkg-config file.
Scope & limitations

An experimental museum release, not a universal ADS-B stack

What it is

A native Linux hardware access library, a reconstructed driver layer for two classic receivers, a small Mode-S/ADS-B decoder and an example CLI.

What it is not

It is not claimed to support every SBS or RadarBox generation, and the current decoder is intentionally smaller than mature ADS-B projects such as full-featured modern receiver stacks. Raw Mode-S frames remain available for applications that need their own decoder.

The implementation is clean-room/interoperability-oriented code based on observed device communications and independently reconstructed behaviour. No vendor SDK is required. License: GNU Lesser General Public License v3.0 or later (LGPL-3.0-or-later).