blackboxer 0.1.1

A Rust library for capturing, logging, and replaying MAVLink messages
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

# MAVLink Blackboxer


A Rust library and set of tools for capturing, logging, and replaying MAVLink messages, designed for drone applications. This project allows you to log MAVLink messages to a custom `.bbin` file format and replay them over TCP, with options for filtering and real-time playback.

## Features


- **Capture**: Connects to a MAVLink endpoint (e.g., `127.0.0.1:14552`) and logs messages to a `.bbin` file.

- **Read**: Parses and displays logged messages from `.bbin` files.

- **Replay**: Replays logged messages to a TCP target, with optional filtering and speed control.

- **Configurable**: Supports armed-only logging and custom connection addresses.

- **Efficient**: Uses bincode for serialization and a custom binary format for logs.


## Installation


1. Ensure you have [Rust](https://www.rust-lang.org/tools/install) installed.

2. Add the library to your project:

 ```
cargo add blackboxer
```
 Or, include in your Cargo.toml:

[dependencies]

```
blackboxer = "0.1.0"
```
For binaries, clone the repository and build:git clone https://github.com/Vivek2518/Blackbox-rs.git

```
cd Blackbox-rs
cargo build --release
```


## Dependencies


```
Rust (edition 2021)
mavlink crate (v0.11)
chrono (v0.4)
serde (v1.0, with derive feature)
bincode (v1.3)
```

## Usage

1. **Capture MAVLink Messages**

Captures MAVLink messages from a TCP endpoint and logs them to a .bbin file.

```
cargo run --bin mavlink-capture -- [ADDRESS] [--armed-only]
```

2. **Read BBIN Files**

Reads and displays messages from a .bbin file.

```
cargo run --bin read-bbin -- <FILE> [--show] [--filter=MSG_TYPE]
```

3. **Replay BBIN Files**

Replays messages from a .bbin file to a TCP target.

```
cargo run --bin replay-bbin -- <FILE> <TCP_TARGET> [--filter=MSG_TYPE] [--realtime] [--speed=VALUE]
```


## Library Usage


Use the library in your Rust code to integrate MAVLink logging:

```
use blackboxer::{BlackBoxer, BlackBoxerConfig};
use std::io;

fn main() -> io::Result<()> {
    let config = BlackBoxerConfig {
        armed_only: true,
        addr: "127.0.0.1:14552".to_string(),
    };
    let mut blackboxer = BlackBoxer::new(config)?;
    blackboxer.capture_messages()?;
    Ok(())
}
```

## Project Structure


src/lib.rs: Core library with BlackBoxer and BbinWriter for logging.
src/bin/main.rs: Binary for capturing messages.
src/bin/read_bbin.rs: Binary for reading logs.
src/bin/replay_bbin.rs: Binary for replaying logs.

## License


This project is licensed under the GNU General Public License v3 (GPL-3.0). Derivative works must be open-sourced under GPL-3.0. See the LICENSE file for details.
Contributing

Fork the repo at https://github.com/Vivek2518/Blackbox-rs.
Submit issues or pull requests for bugs, features, or improvements via GitHub.

## Support


If you find this project useful, consider supporting development:

Feel free to reach out

## Contact


Author: Vivek Patwari
Email: vivekpatwari38@gmail.com
Repository: https://github.com/Vivek2518/Blackbox-rs