mavlink 0.18.0

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

mod test_shared;

#[cfg(feature = "dialect-common")]
mod test_file_connections {
    use mavlink::MavConnection;
    use mavlink::dialects::ardupilotmega::MavMessage;

    /// Test whether we can send a message via TCP and receive it OK using async_connect.
    /// This also test signing as a property of a MavConnection if the mav2-message-signing feature is enabled.
    #[cfg(feature = "tokio")]
    #[tokio::test]
    pub async fn test_file_async_read_raw() {
        let tlog = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("tests/log.tlog")
            .canonicalize()
            .unwrap();

        let tlog = tlog.to_str().unwrap();

        let filename = std::path::Path::new(tlog);
        let filename = filename.to_str().unwrap();
        dbg!(filename);

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

        println!("connection_string - {connection_string}");

        let vehicle = mavlink::connect_async::<MavMessage>(&connection_string)
            .await
            .expect("Couldn't read from file");

        let mut counter = 0;
        loop {
            match vehicle.recv_raw().await {
                Ok(raw_msg) => {
                    println!(
                        "raw_msg.component_id() {} | sequence number {} | message_id {:?}",
                        raw_msg.component_id(),
                        raw_msg.sequence(),
                        raw_msg.message_id()
                    );

                    counter += 1;
                }
                Err(mavlink::error::MessageReadError::Io(e)) => {
                    if e.kind() == tokio::io::ErrorKind::UnexpectedEof {
                        break;
                    }
                }
                _ => {
                    break;
                }
            }
        }

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

    #[test]
    pub fn test_file_read_raw() {
        let tlog = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("tests/log.tlog")
            .canonicalize()
            .unwrap();

        let tlog = tlog.to_str().unwrap();

        let filename = std::path::Path::new(tlog);
        let filename = filename.to_str().unwrap();
        dbg!(filename);

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

        println!("connection_string - {connection_string}");

        let vehicle =
            mavlink::connect::<MavMessage>(&connection_string).expect("Couldn't read from file");

        let mut counter = 0;
        loop {
            match vehicle.recv_raw() {
                Ok(raw_msg) => {
                    println!(
                        "raw_msg.component_id() {} | sequence number {} | message_id {:?}",
                        raw_msg.component_id(),
                        raw_msg.sequence(),
                        raw_msg.message_id()
                    );

                    counter += 1;
                }
                Err(mavlink::error::MessageReadError::Io(e)) => {
                    if e.kind() == tokio::io::ErrorKind::UnexpectedEof {
                        break;
                    }
                }
                _ => {
                    break;
                }
            }
        }

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