e_drone/protocol/external/
system.rs1use num_enum::IntoPrimitive;
2use num_enum::TryFromPrimitive;
3use std::convert::TryFrom;
4
5use crate::protocol::Serializable;
6use crate::communication::extractor::Extractor;
7
8
9#[derive(Clone, Copy, Debug, Eq, PartialEq, IntoPrimitive, TryFromPrimitive)]
12#[repr(u8)]
13pub enum ModeSystem {
14 #[num_enum(default)]
15 None = 0x00, Stop = 0x01, Error = 0x02, Run = 0x10, }
21
22
23impl ModeSystem {
24 pub fn from_u8(data_u8: u8) -> ModeSystem {
25 match ModeSystem::try_from( data_u8 ) {
26 Ok(data) => { data },
27 _ => { ModeSystem::None },
28 }
29 }
30}
31
32
33#[derive(Clone, Copy, Debug, Eq, PartialEq, IntoPrimitive, TryFromPrimitive)]
36#[repr(u8)]
37pub enum CommandType {
38 #[num_enum(default)]
39 None = 0x00, Shutdown = 0x01, Reboot = 0x02, }
43
44
45impl CommandType {
46 pub fn from_u8(data_u8: u8) -> CommandType {
47 match CommandType::try_from( data_u8 ) {
48 Ok(data) => { data },
49 _ => { CommandType::None },
50 }
51 }
52}
53
54
55#[derive(Debug, Copy, Clone)]
57pub struct State {
58 pub mode_system: ModeSystem,
59 pub fps: u16,
60}
61
62
63impl State {
64 pub fn new() -> State{
65 State {
66 mode_system: ModeSystem::None,
67 fps: 0,
68 }
69 }
70
71
72 pub const fn size() -> usize { 3 }
73
74
75 pub fn parse(slice_data: &[u8]) -> Result<State, &'static str> {
76 if slice_data.len() == State::size() {
77 let mut ext: Extractor = Extractor::from_slice(slice_data);
78 Ok(State{
79 mode_system: ModeSystem::from_u8(ext.get_u8()),
80 fps: ext.get_u16(),
81 })
82 }
83 else { Err("Wrong length") }
84 }
85}
86
87
88impl Serializable for State {
89 fn to_vec(&self) -> Vec<u8> {
90 let mut vec_data : Vec<u8> = Vec::new();
91
92 vec_data.push(self.mode_system.into());
93 vec_data.extend_from_slice(&self.fps.to_le_bytes());
94
95 vec_data
96 }
97}
98
99
100
101#[derive(Debug, Copy, Clone)]
103pub struct Command {
104 pub command_type: CommandType,
105}
106
107
108impl Command {
109 pub fn new() -> Command{
110 Command {
111 command_type: CommandType::None,
112 }
113 }
114
115
116 pub const fn size() -> usize { 1 }
117
118
119 pub fn parse(slice_data: &[u8]) -> Result<Command, &'static str> {
120 if slice_data.len() == Command::size() {
121 let mut ext: Extractor = Extractor::from_slice(slice_data);
122 Ok(Command{
123 command_type: CommandType::from_u8(ext.get_u8()),
124 })
125 }
126 else { Err("Wrong length") }
127 }
128}
129
130
131impl Serializable for Command {
132 fn to_vec(&self) -> Vec<u8> {
133 let mut vec_data : Vec<u8> = Vec::new();
134
135 vec_data.push(self.command_type.into());
136
137 vec_data
138 }
139}
140