Skip to content

Latest commit

 

History

History
138 lines (99 loc) · 3.37 KB

README.md

File metadata and controls

138 lines (99 loc) · 3.37 KB
Raw

sbus-rs

Crates.io Documentation License: MIT

A no_std compatible Rust implementation of the SBUS (Serial Bus) protocol parser, commonly used in RC (Radio Control) applications. Part of the AeroRust organization, dedicated to aerospace-related software in Rust.

Features

  • 🦀 Pure Rust implementation
  • 🚫 no_std compatible for embedded systems
  • ⚡ Async and blocking IO support
  • 🔍 Robust error handling and validation
  • 🧪 Thoroughly tested with unit tests, property-based tests, and fuzzing
  • 📊 Benchmarked for performance optimization
  • 🛠️ Zero-copy parsing for efficient memory usage

Installation

Add this to your Cargo.toml:

[dependencies]
sbus-rs = "0.1.0"

For async support:

[dependencies]
sbus-rs = { version = "0.1.0", features = ["async"] }

Usage

Blocking Example

use sbus_rs::{SbusParser, SbusError};
use embedded_io_adapters::std::FromStd;

fn main() -> Result<(), SbusError> {
    let serial = /* your serial port */;
    let mut parser = SbusParser::new(FromStd::new(serial));
    
    // Read a single SBUS frame
    let frame = parser.read_frame()?;
    
    // Access channel values (0-2047)
    println!("Channel 1: {}", frame.channels[0]);
    
    // Check flags
    if frame.flags.failsafe {
        println!("Failsafe active!");
    }
    
    Ok(())
}

Async Example

use sbus_rs::{SbusParserAsync, SbusError};
use embedded_io_adapters::tokio_1::FromTokio;

async fn read_sbus() -> Result<(), SbusError> {
    let serial = /* your async serial port */;
    let mut parser = SbusParserAsync::new(FromTokio::new(serial));
    
    // Read frames asynchronously
    let frame = parser.read_frame().await?;
    
    println!("Channels: {:?}", frame.channels);
    println!("Frame lost: {}", frame.flags.frame_lost);
    
    Ok(())
}

Protocol Details

SBUS frames consist of:

  • Start byte (0x0F)
  • 22 bytes of channel data (16 channels, 11 bits each)
  • 1 byte of flags
  • End byte (0x00)

Channel values range from 0 to 2047 (11 bits).

Flag bits:

  • Digital Channel 1
  • Digital Channel 2
  • Frame Lost
  • Failsafe Active

Performance

The library is optimized for performance with careful consideration of:

  • Zero-copy parsing
  • Efficient bit manipulation
  • Minimal allocations
  • Vectorization opportunities

Benchmarks are available and can be run with:

cargo bench

Contributing

Contributions are welcome! Please feel free to submit a Pull Request. Make sure to:

  1. Run the full test suite: cargo test --all-features
  2. Run benchmarks: cargo bench
  3. Run clippy: cargo clippy --all-features
  4. Format code: cargo fmt

Safety

The crate uses safe Rust and includes:

  • Miri checks for undefined behavior
  • Memory sanitizer tests
  • Fuzzing tests
  • Property-based testing

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Part of the AeroRust organization, promoting the use of Rust in aerospace applications.

Special thanks to:

  • The AeroRust community
  • Contributors and maintainers
  • The Rust embedded community