ross_protocol/event/
general.rs

1use alloc::vec;
2use alloc::vec::Vec;
3use core::convert::TryInto;
4
5use crate::convert_packet::{ConvertPacket, ConvertPacketError};
6use crate::event::event_code::*;
7use crate::event::EventError;
8use crate::packet::Packet;
9
10#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
11pub struct AckEvent {
12    pub receiver_address: u16,
13    pub transmitter_address: u16,
14}
15
16impl ConvertPacket<AckEvent> for AckEvent {
17    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
18        if packet.data.len() != 4 {
19            return Err(ConvertPacketError::WrongSize);
20        }
21
22        if packet.is_error {
23            return Err(ConvertPacketError::WrongType);
24        }
25
26        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap()) != ACK_EVENT_CODE {
27            return Err(ConvertPacketError::Event(EventError::WrongEventType));
28        }
29
30        let receiver_address = packet.device_address;
31        let transmitter_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
32
33        Ok(AckEvent {
34            receiver_address,
35            transmitter_address,
36        })
37    }
38
39    fn to_packet(&self) -> Packet {
40        let mut data = vec![];
41
42        for byte in u16::to_be_bytes(ACK_EVENT_CODE).iter() {
43            data.push(*byte);
44        }
45
46        for byte in u16::to_be_bytes(self.transmitter_address).iter() {
47            data.push(*byte);
48        }
49
50        Packet {
51            is_error: false,
52            device_address: self.receiver_address,
53            data,
54        }
55    }
56}
57
58#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
59pub struct DataEvent {
60    pub receiver_address: u16,
61    pub transmitter_address: u16,
62    pub data_len: u16,
63    pub data: Vec<u8>,
64}
65
66impl ConvertPacket<DataEvent> for DataEvent {
67    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
68        if packet.is_error {
69            return Err(ConvertPacketError::WrongType);
70        }
71
72        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap()) != DATA_EVENT_CODE {
73            return Err(ConvertPacketError::Event(EventError::WrongEventType));
74        }
75
76        let receiver_address = packet.device_address;
77        let transmitter_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
78        let data_len = u16::from_be_bytes(packet.data[4..=5].try_into().unwrap());
79
80        if packet.data.len() != data_len as usize + 6 {
81            return Err(ConvertPacketError::WrongSize);
82        }
83
84        let mut data = vec![0; data_len as usize];
85
86        for i in 0..data_len as usize {
87            data[i] = packet.data[i + 6];
88        }
89
90        Ok(DataEvent {
91            receiver_address,
92            transmitter_address,
93            data_len,
94            data,
95        })
96    }
97
98    fn to_packet(&self) -> Packet {
99        let mut data = vec![];
100
101        for byte in u16::to_be_bytes(DATA_EVENT_CODE).iter() {
102            data.push(*byte);
103        }
104
105        for byte in u16::to_be_bytes(self.transmitter_address).iter() {
106            data.push(*byte);
107        }
108
109        for byte in u16::to_be_bytes(self.data_len).iter() {
110            data.push(*byte);
111        }
112
113        for byte in self.data.iter() {
114            data.push(*byte);
115        }
116
117        Packet {
118            is_error: false,
119            device_address: self.receiver_address,
120            data,
121        }
122    }
123}
124
125#[cfg(test)]
126mod tests {
127    use super::*;
128
129    const EVENT_PACKET: Packet = Packet {
130        is_error: false,
131        device_address: 0xabab,
132        data: vec![],
133    };
134
135    #[test]
136    fn ack_try_from_packet_test() {
137        let mut packet = EVENT_PACKET;
138        packet.data = vec![
139            ((ACK_EVENT_CODE >> 8) & 0xff) as u8, // event code
140            ((ACK_EVENT_CODE >> 0) & 0xff) as u8, // event code
141            0x01,                                 // transmitter address
142            0x23,                                 // transmitter address
143        ];
144
145        let event = AckEvent::try_from_packet(&packet).unwrap();
146
147        assert_eq!(event.receiver_address, 0xabab);
148        assert_eq!(event.transmitter_address, 0x0123);
149    }
150
151    #[test]
152    fn ack_to_packet_test() {
153        let event = AckEvent {
154            receiver_address: 0xabab,
155            transmitter_address: 0x0123,
156        };
157
158        let mut packet = EVENT_PACKET;
159        packet.data = vec![
160            ((ACK_EVENT_CODE >> 8) & 0xff) as u8, // event code
161            ((ACK_EVENT_CODE >> 0) & 0xff) as u8, // event code
162            0x01,                                 // transmitter address
163            0x23,                                 // transmitter address
164        ];
165
166        assert_eq!(event.to_packet(), packet);
167    }
168
169    #[test]
170    fn data_try_from_packet_test() {
171        let mut packet = EVENT_PACKET;
172        packet.data = vec![
173            ((DATA_EVENT_CODE >> 8) & 0xff) as u8, // event code
174            ((DATA_EVENT_CODE >> 0) & 0xff) as u8, // event code
175            0x01,                                  // transmitter address
176            0x23,                                  // transmitter address
177            0x00,                                  // data len
178            0x05,                                  // data len
179            0x00,                                  // data
180            0x01,                                  // data
181            0x02,                                  // data
182            0x03,                                  // data
183            0x04,                                  // data
184        ];
185
186        let event = DataEvent::try_from_packet(&packet).unwrap();
187
188        assert_eq!(event.receiver_address, 0xabab);
189        assert_eq!(event.transmitter_address, 0x0123);
190        assert_eq!(event.data_len, 0x0005);
191        assert_eq!(event.data, vec!(0x00, 0x01, 0x02, 0x03, 0x04));
192    }
193
194    #[test]
195    fn data_to_packet_test() {
196        let event = DataEvent {
197            receiver_address: 0xabab,
198            transmitter_address: 0x0123,
199            data_len: 0x0005,
200            data: vec![0x00, 0x01, 0x02, 0x03, 0x04],
201        };
202
203        let mut packet = EVENT_PACKET;
204        packet.data = vec![
205            ((DATA_EVENT_CODE >> 8) & 0xff) as u8, // event code
206            ((DATA_EVENT_CODE >> 0) & 0xff) as u8, // event code
207            0x01,                                  // transmitter address
208            0x23,                                  // transmitter address
209            0x00,                                  // data len
210            0x05,                                  // data len
211            0x00,                                  // data
212            0x01,                                  // data
213            0x02,                                  // data
214            0x03,                                  // data
215            0x04,                                  // data
216        ];
217
218        assert_eq!(event.to_packet(), packet);
219    }
220}
ross_protocol/event/general.rs

ross_protocol/event/
general.rs
