remote-id 0.1.2

Remote ID Implementation as Specified in ASTM F3411 - 22a
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

use crate::MAX_ID_BYTE_SIZE;

pub const MESSAGE_TYPE: u8 = 0;

#[derive(Debug, Clone, PartialEq)]
pub struct BasicId {
    pub id_type: IdType,
    pub ua_type: UAType,
    pub uas_id: [u8; MAX_ID_BYTE_SIZE],
}

#[derive(Debug, Copy, Clone, PartialEq)]
pub enum IdType {
    None = 0,
    /// ANSI/CTA-2063-A
    SerialNumber = 1,
    CaaRegistrationId = 2,
    UtmAssignedId = 3,
    SpecificSessionId = 4,
}

impl From<u8> for IdType {
    fn from(value: u8) -> Self {
        match value {
            0 => IdType::None,
            1 => IdType::SerialNumber,
            2 => IdType::CaaRegistrationId,
            3 => IdType::UtmAssignedId,
            4 => IdType::SpecificSessionId,

            _ => IdType::None,
        }
    }
}

impl From<IdType> for u8 {
    fn from(val: IdType) -> Self {
        match val {
            IdType::None => 0,
            IdType::SerialNumber => 1,
            IdType::CaaRegistrationId => 2,
            IdType::UtmAssignedId => 3,
            IdType::SpecificSessionId => 4,
        }
    }
}

#[derive(Debug, Copy, Clone, PartialEq)]
pub enum UAType {
    None = 0,
    Aeroplane = 1,
    HelicopterOrMultirotor = 2,
    Gyroplane = 3,
    HybridLift = 4,
    Ornithopter = 5,
    Glider = 6,
    Kite = 7,
    FreeBalloon = 8,
    CaptiveBalloon = 9,
    Airship = 10,
    FreeFallParachute = 11,
    Rocket = 12,
    TetheredPoweredAircraft = 13,
    GroundObstacle = 14,
    Other = 15,
}

impl From<u8> for UAType {
    fn from(value: u8) -> Self {
        match value {
            0 => UAType::None,
            1 => UAType::Aeroplane,
            2 => UAType::HelicopterOrMultirotor,
            3 => UAType::Gyroplane,
            4 => UAType::HybridLift,
            5 => UAType::Ornithopter,
            6 => UAType::Glider,
            7 => UAType::Kite,
            8 => UAType::FreeBalloon,
            9 => UAType::CaptiveBalloon,
            10 => UAType::Airship,
            11 => UAType::FreeFallParachute,
            12 => UAType::Rocket,
            13 => UAType::TetheredPoweredAircraft,
            14 => UAType::GroundObstacle,
            _ => UAType::Other,
        }
    }
}

impl From<UAType> for u8 {
    fn from(val: UAType) -> Self {
        match val {
            UAType::Aeroplane => 1,
            UAType::HelicopterOrMultirotor => 2,
            UAType::Gyroplane => 3,
            UAType::HybridLift => 4,
            UAType::Ornithopter => 5,
            UAType::Glider => 6,
            UAType::Kite => 7,
            UAType::FreeBalloon => 8,
            UAType::CaptiveBalloon => 9,
            UAType::Airship => 10,
            UAType::FreeFallParachute => 11,
            UAType::Rocket => 12,
            UAType::TetheredPoweredAircraft => 13,
            UAType::GroundObstacle => 14,
            UAType::Other => 15,

            UAType::None => 0,
        }
    }
}