Rust ULog Parser

A robust Rust implementation of a parser for the ULog file format, commonly used in PX4 flight stack for logging system data. This parser provides a safe, efficient way to read and process ULog files with strong type checking and error handling.

Project Status

This project is currently in development, it basically works but I'll be making changes to the interface as I go.

Parse ULog files and extract all messages
Make a nice interface for the parser (in progress)
Documentation
Add cli features for the binary (right now it just gives some summary data for a sanity check)
Add tests (Parity tests are in progress, using pyulog for comparison. The holdup is munging the data to match the format from pyulog)
Benchmarking

Features

Complete implementation of the ULog file format specification
Support for all ULog message types including:
- Data messages
- Format messages
- Parameter messages
- Logged messages (both plain and tagged)
- Multi messages
- Subscription messages
- Dropout tracking
Safe handling of nested message types
Comprehensive error handling
Zero-copy parsing where possible
Support for appended data sections

Usage

Add this to your Cargo.toml:

[dependencies]
ulog_rs = "0.0.1"

Basic Example

use std::fs::File;
use ulog_rs::ULogParser;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Open a ULog file
    let file = File::open("sample.ulg")?;
    
    // Create parser instance
    let parser = ULogParser::parse_reader(file)?;
    
    // Access header information
    println!("ULog Header:");
    println!("  Version: {}", parser.header().version);
    println!("  Timestamp: {} μs", parser.header().timestamp);
    println!("  Final Timestamp: {} μs", parser.last_timestamp());
    
    // Access logged messages
    for message in parser.logged_messages() {
        println!("[{}] {}", message.timestamp, message.message);
    }
    
    Ok(())
}

Project Structure

The project is organized into several modules, each handling specific aspects of ULog parsing:

lib.rs: Core parser implementation and type definitions
data_message.rs: Handles data message parsing
dropout_message.rs: Manages dropout tracking and statistics
format_message.rs: Processes message format definitions
info_message.rs: Handles info message parsing
logged_message.rs: Manages regular logged messages
multi_message.rs: Handles multi-part messages
parameter_message.rs: Processes parameter messages
subscription_message.rs: Manages message subscriptions
tagged_logged_message.rs: Handles tagged log messages

API Overview

Main Parser Interface

The ULog struct provides the main interface for parsing ULog files:

use ulog_rs::ulog::ULog;
let ulog = ULog::parse_file("sample.ulg")?;

// Access header information
println!("Version: {}", ulog.version);
println!("Timestamp: {} μs", ulog.timestamp);
// Get logged messages
for message in &ulog.logged_messages() {
    println!("[{}] {}", message.timestamp, message.message);
}

Contributing

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

License

MIT License

ulog-rs 0.0.2