mavlink 0.10.13

Implements the MAVLink data interchange format for UAVs.
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

extern crate mavlink;

#[cfg(test)]
#[cfg(ignore)]
#[cfg(all(feature = "default", feature = "ardupilotmega"))]
mod process_files {
    use mavlink::ardupilotmega::MavMessage;
    use mavlink::error::MessageReadError;

    #[test]
    pub fn all() {
        // Get path for download script
        let test_script = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("tests/download_log_files.sh")
            .canonicalize()
            .unwrap();
        let test_script = test_script.to_str().unwrap();

        // Run download script
        let result = std::process::Command::new("sh").arg(test_script).output();
        assert_eq!(result.is_ok(), true);

        // Grab all log files
        let test_path = "/tmp/testlogs/";
        let files = std::fs::read_dir(test_path).unwrap();
        let mut files = files
            .filter_map(Result::ok)
            .filter(|d| d.path().extension().unwrap_or_default().to_str() == Some("tlog"));

        while let Some(file) = files.next() {
            let filename = file.file_name();
            let filename = filename.to_str().unwrap();
            let filename = std::path::Path::new(test_path)
                .join(filename)
                .canonicalize()
                .unwrap();
            let filename = filename.to_str().unwrap();

            println!("Processing file: {}", &filename);
            let connection_string = format!("file:{}", &filename);

            // Process file
            process_file(&connection_string);
        }
    }

    pub fn process_file(connection_string: &str) {
        let vehicle = mavlink::connect::<MavMessage>(&connection_string);
        assert!(vehicle.is_ok(), "Incomplete address should error");

        let vehicle = vehicle.unwrap();
        let mut counter = 0;
        loop {
            match vehicle.recv() {
                Ok((_header, msg)) => {
                    counter += 1;
                }
                Err(MessageReadError::Io(e)) => match e.kind() {
                    std::io::ErrorKind::WouldBlock => {
                        continue;
                    }
                    _ => {
                        println!("recv error: {:?}", e);
                        break;
                    }
                },
                _ => {}
            }
        }

        println!("Number of parsed messages: {}", counter);
        assert!(
            counter > 11128,
            "Unable to hit the necessary amount of matches"
        );
    }
}