48 releases

0.4.1 Nov 14, 2023
0.4.0 Nov 14, 2023
0.3.11 Nov 17, 2023
0.3.10 Oct 29, 2023
0.1.15 Sep 20, 2023

#2 in #digital-signal-processing

Download history 4/week @ 2024-02-22 58/week @ 2024-02-29 587/week @ 2024-03-07 6/week @ 2024-03-14 1/week @ 2024-03-28

594 downloads per month

MIT license

170KB
4K SLoC

Rust Radio

A library for digital signals processing in the spirit of GNU Radio.

For extra speed(?), build with env RUSTFLAGS="-C target-cpu=native"

Publish new version

./extra/bump_version.sh
git push && cargo publish

Benchmark

cargo +nightly bench

Useful commands

Plot I/Q data

$ od -A none -w8 -f test.c32 > t
$ gnuplot
gnuplot> plot 't' using 1 w l, 't' using 2 w l

lib.rs:

This create provides a framework for running SDR (software defined radio) applications.

It's heavily inspired by GNURadio, except of course written in Rust.

It currently has very few blocks, and is missing tags, and PDU messages.

In addition to the example applications in this crate, there's also a sparslog project using this framework, that decodes IKEA Sparsnäs electricity meter RF signals.

Architecture overview

A RustRadio application consists of blocks that are connected by unidirectional streams. Each block has zero or more input streams, and zero or more output streams.

The signal flows through the blocks from "sources" (blocks without any input streams) to "sinks" (blocks without any output streams.

These blocks and streams are called a "graph", like the mathematical concept of graphs that have nodes and edges.

A block does something to its input(s), and passes the result to its output(s).

A typical graph will be something like:

[ Raw radio source ]
↓
[ Filtering ]
↓
[ Resampling ]
↓
[ Demodulation ]
↓
[ Symbol Sync ]
↓
[ Packet assembly and save ]

Or concretely, for sparslog:

[ RtlSdrSource ]
↓
[ RtlSdrDecode to convert from ]
[ own format to complex I/Q    ]
↓
[ FftFilter ]
↓
[ RationalResampler ]
↓
[ QuadratureDemod ]
↓
[ AddConst for frequency offset ]
↓
[ ZeroCrossing symbol sync ]
↓
[ Custom Sparsnäs decoder ]
[ block in the binary,    ]
[ not in the framework    ]

Examples

Here's a simple example that creates a couple of blocks, connects them with streams, and runs the graph.

use rustradio::graph::Graph;
use rustradio::blocks::{AddConst, VectorSource, DebugSink};
use rustradio::Complex;
let src = Box::new(VectorSource::new(
vec![
Complex::new(10.0, 0.0),
Complex::new(-20.0, 0.0),
Complex::new(100.0, -100.0),
],
));
let add = Box::new(AddConst::new(src.out(), Complex::new(1.1, 2.0)));
let sink = Box::new(DebugSink::new(add.out()));
let mut g = Graph::new();
g.add(src);
g.add(add);
g.add(sink);
g.run()?;

Test helper functions.

Dependencies

~5–15MB
~175K SLoC