mavio 0.5.10

Minimalistic MAVLink client that supports `no-std` and `no-alloc` targets.
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

pub(crate) mod sealed_traits {
    pub trait IsPayloadLen {}
    pub trait IsSequenced {}
    pub trait IsSysId {}
    pub trait IsCompId {}
    pub trait IsMsgId {}
    pub trait IsPayload {}
    pub trait IsCrcExtra {}
    pub trait IsSigned {
        fn is_signed(&self) -> bool {
            false
        }
    }
}
pub(crate) use sealed_traits::*;

mod payload_len {
    use super::IsPayloadLen;
    use crate::protocol::{PayloadLength, Unset};

    impl IsPayloadLen for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasPayloadLen(pub(crate) PayloadLength);
    impl IsPayloadLen for HasPayloadLen {}
}
pub use payload_len::*;

mod sequenced {
    use super::IsSequenced;
    use crate::protocol::{Sequence, Unset};

    impl IsSequenced for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct Sequenced(pub(crate) Sequence);
    impl IsSequenced for Sequenced {}
}
pub use sequenced::*;

mod sys_id {
    use super::IsSysId;
    use crate::protocol::{SystemId, Unset};

    impl IsSysId for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasSysId(pub(crate) SystemId);
    impl IsSysId for HasSysId {}
}
pub use sys_id::*;

mod comp_id {
    use super::IsCompId;
    use crate::protocol::{ComponentId, Unset};

    impl IsCompId for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasCompId(pub(crate) ComponentId);
    impl IsCompId for HasCompId {}
}
pub use comp_id::*;

mod msg_id {
    use super::IsMsgId;
    use crate::protocol::{MessageId, Unset};

    impl IsMsgId for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasMsgId(pub(crate) MessageId);
    impl IsMsgId for HasMsgId {}
}
pub use msg_id::*;

mod payload {
    use super::IsPayload;
    use crate::protocol::{Payload, Unset};

    impl IsPayload for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasPayload(pub(crate) Payload);
    impl IsPayload for HasPayload {}
}
pub use payload::*;

mod crc {
    use super::IsCrcExtra;
    use crate::protocol::{CrcExtra, Unset};

    impl IsCrcExtra for Unset {}
    #[derive(Clone, Debug, Default)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasCrcExtra(pub(crate) CrcExtra);
    impl IsCrcExtra for HasCrcExtra {}
}
pub use crc::*;

mod signed {
    use super::IsSigned;
    use crate::protocol::{Signature, Unset};

    impl IsSigned for Unset {
        fn is_signed(&self) -> bool {
            false
        }
    }
    #[derive(Clone, Debug)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct HasSignature(#[allow(dead_code)] pub(crate) Signature);
    impl IsSigned for HasSignature {
        fn is_signed(&self) -> bool {
            true
        }
    }
}
pub use signed::*;