ross_protocol/event/
programmer.rs

1use alloc::vec;
2use core::convert::TryInto;
3
4use crate::convert_packet::{ConvertPacket, ConvertPacketError};
5use crate::event::event_code::*;
6use crate::event::EventError;
7use crate::packet::Packet;
8use crate::protocol::BROADCAST_ADDRESS;
9
10#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
11pub struct ProgrammerHelloEvent {
12    pub programmer_address: u16,
13}
14
15impl ConvertPacket<ProgrammerHelloEvent> for ProgrammerHelloEvent {
16    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
17        if packet.data.len() != 4 {
18            return Err(ConvertPacketError::WrongSize);
19        }
20
21        if packet.is_error {
22            return Err(ConvertPacketError::WrongType);
23        }
24
25        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap()) != PROGRAMMER_HELLO_EVENT_CODE
26        {
27            return Err(ConvertPacketError::Event(EventError::WrongEventType));
28        }
29
30        let programmer_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
31
32        Ok(ProgrammerHelloEvent { programmer_address })
33    }
34
35    fn to_packet(&self) -> Packet {
36        let mut data = vec![];
37
38        for byte in u16::to_be_bytes(PROGRAMMER_HELLO_EVENT_CODE).iter() {
39            data.push(*byte);
40        }
41
42        for byte in u16::to_be_bytes(self.programmer_address).iter() {
43            data.push(*byte);
44        }
45
46        Packet {
47            is_error: false,
48            device_address: BROADCAST_ADDRESS,
49            data,
50        }
51    }
52}
53
54#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
55pub struct ProgrammerStartFirmwareUpgradeEvent {
56    pub receiver_address: u16,
57    pub programmer_address: u16,
58    pub firmware_size: u32,
59}
60
61impl ConvertPacket<ProgrammerStartFirmwareUpgradeEvent> for ProgrammerStartFirmwareUpgradeEvent {
62    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
63        if packet.data.len() != 8 {
64            return Err(ConvertPacketError::WrongSize);
65        }
66
67        if packet.is_error {
68            return Err(ConvertPacketError::WrongType);
69        }
70
71        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap())
72            != PROGRAMMER_START_FIRMWARE_UPGRADE_EVENT_CODE
73        {
74            return Err(ConvertPacketError::Event(EventError::WrongEventType));
75        }
76
77        let receiver_address = packet.device_address;
78        let programmer_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
79        let firmware_size = u32::from_be_bytes(packet.data[4..=7].try_into().unwrap());
80
81        Ok(ProgrammerStartFirmwareUpgradeEvent {
82            receiver_address,
83            programmer_address,
84            firmware_size,
85        })
86    }
87
88    fn to_packet(&self) -> Packet {
89        let mut data = vec![];
90
91        for byte in u16::to_be_bytes(PROGRAMMER_START_FIRMWARE_UPGRADE_EVENT_CODE).iter() {
92            data.push(*byte);
93        }
94
95        for byte in u16::to_be_bytes(self.programmer_address).iter() {
96            data.push(*byte);
97        }
98
99        for byte in u32::to_be_bytes(self.firmware_size).iter() {
100            data.push(*byte);
101        }
102
103        Packet {
104            is_error: false,
105            device_address: self.receiver_address,
106            data,
107        }
108    }
109}
110
111#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
112pub struct ProgrammerStartConfigUpgradeEvent {
113    pub receiver_address: u16,
114    pub programmer_address: u16,
115    pub config_size: u32,
116}
117
118impl ConvertPacket<ProgrammerStartConfigUpgradeEvent> for ProgrammerStartConfigUpgradeEvent {
119    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
120        if packet.data.len() != 8 {
121            return Err(ConvertPacketError::WrongSize);
122        }
123
124        if packet.is_error {
125            return Err(ConvertPacketError::WrongType);
126        }
127
128        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap())
129            != PROGRAMMER_START_CONFIG_UPGRADE_EVENT_CODE
130        {
131            return Err(ConvertPacketError::Event(EventError::WrongEventType));
132        }
133
134        let receiver_address = packet.device_address;
135        let programmer_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
136        let config_size = u32::from_be_bytes(packet.data[4..=7].try_into().unwrap());
137
138        Ok(ProgrammerStartConfigUpgradeEvent {
139            receiver_address,
140            programmer_address,
141            config_size,
142        })
143    }
144
145    fn to_packet(&self) -> Packet {
146        let mut data = vec![];
147
148        for byte in u16::to_be_bytes(PROGRAMMER_START_CONFIG_UPGRADE_EVENT_CODE).iter() {
149            data.push(*byte);
150        }
151
152        for byte in u16::to_be_bytes(self.programmer_address).iter() {
153            data.push(*byte);
154        }
155
156        for byte in u32::to_be_bytes(self.config_size).iter() {
157            data.push(*byte);
158        }
159
160        Packet {
161            is_error: false,
162            device_address: self.receiver_address,
163            data,
164        }
165    }
166}
167
168#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
169pub struct ProgrammerSetDeviceAddressEvent {
170    pub receiver_address: u16,
171    pub programmer_address: u16,
172    pub new_address: u16,
173}
174
175impl ConvertPacket<ProgrammerSetDeviceAddressEvent> for ProgrammerSetDeviceAddressEvent {
176    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
177        if packet.data.len() != 6 {
178            return Err(ConvertPacketError::WrongSize);
179        }
180
181        if packet.is_error {
182            return Err(ConvertPacketError::WrongType);
183        }
184
185        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap())
186            != PROGRAMMER_SET_DEVICE_ADDRESS_EVENT_CODE
187        {
188            return Err(ConvertPacketError::Event(EventError::WrongEventType));
189        }
190
191        let receiver_address = packet.device_address;
192        let programmer_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
193        let new_address = u16::from_be_bytes(packet.data[4..=5].try_into().unwrap());
194
195        Ok(ProgrammerSetDeviceAddressEvent {
196            receiver_address,
197            programmer_address,
198            new_address,
199        })
200    }
201
202    fn to_packet(&self) -> Packet {
203        let mut data = vec![];
204
205        for byte in u16::to_be_bytes(PROGRAMMER_SET_DEVICE_ADDRESS_EVENT_CODE).iter() {
206            data.push(*byte);
207        }
208
209        for byte in u16::to_be_bytes(self.programmer_address).iter() {
210            data.push(*byte);
211        }
212
213        for byte in u16::to_be_bytes(self.new_address).iter() {
214            data.push(*byte);
215        }
216
217        Packet {
218            is_error: false,
219            device_address: self.receiver_address,
220            data,
221        }
222    }
223}
224
225#[cfg(test)]
226mod tests {
227    use super::*;
228
229    const EVENT_PACKET: Packet = Packet {
230        is_error: false,
231        device_address: 0xabab,
232        data: vec![],
233    };
234
235    #[test]
236    fn hello_try_from_packet_test() {
237        let mut packet = EVENT_PACKET;
238
239        packet.data = vec![
240            ((PROGRAMMER_HELLO_EVENT_CODE >> 8) & 0xff) as u8, // event code
241            ((PROGRAMMER_HELLO_EVENT_CODE >> 0) & 0xff) as u8, // event code
242            0x01,                                              // programmer address
243            0x23,                                              // programmer address
244        ];
245
246        let event = ProgrammerHelloEvent::try_from_packet(&packet).unwrap();
247
248        assert_eq!(event.programmer_address, 0x0123);
249    }
250
251    #[test]
252    #[should_panic]
253    fn hello_try_from_packet_wrong_size_test() {
254        let mut packet = EVENT_PACKET;
255        packet.data = vec![
256            ((PROGRAMMER_HELLO_EVENT_CODE >> 8) & 0xff) as u8, // event code
257            ((PROGRAMMER_HELLO_EVENT_CODE >> 0) & 0xff) as u8, // event code
258            0x01,                                              // programmer address
259            0x34,                                              // programmer address
260            0x00,                                              // extra byte
261        ];
262
263        ProgrammerHelloEvent::try_from_packet(&packet).unwrap();
264    }
265
266    #[test]
267    #[should_panic]
268    fn hello_try_from_packet_wrong_type_test() {
269        let mut packet = EVENT_PACKET;
270        packet.data = vec![
271            ((PROGRAMMER_HELLO_EVENT_CODE >> 8) & 0xff) as u8, // event code
272            ((PROGRAMMER_HELLO_EVENT_CODE >> 0) & 0xff) as u8, // event code
273            0x01,                                              // programmer address
274            0x34,                                              // programmer address
275        ];
276        packet.is_error = true;
277
278        ProgrammerHelloEvent::try_from_packet(&packet).unwrap();
279    }
280
281    #[test]
282    #[should_panic]
283    fn hello_try_from_packet_wrong_event_type_test() {
284        let mut packet = EVENT_PACKET;
285        packet.data = vec![
286            ((BOOTLOADER_HELLO_EVENT_CODE >> 8) & 0xff) as u8, // event code
287            ((BOOTLOADER_HELLO_EVENT_CODE >> 0) & 0xff) as u8, // event code
288            0x01,                                              // bootloader address
289            0x23,                                              // bootloader address
290        ];
291
292        ProgrammerHelloEvent::try_from_packet(&packet).unwrap();
293    }
294
295    #[test]
296    fn hello_to_packet_test() {
297        let event = ProgrammerHelloEvent {
298            programmer_address: 0x0123,
299        };
300
301        let mut packet = EVENT_PACKET;
302        packet.device_address = BROADCAST_ADDRESS;
303        packet.data = vec![
304            ((PROGRAMMER_HELLO_EVENT_CODE >> 8) & 0xff) as u8, // event code
305            ((PROGRAMMER_HELLO_EVENT_CODE >> 0) & 0xff) as u8, // event code
306            0x01,                                              // programmer address
307            0x23,                                              // programmer address
308        ];
309
310        assert_eq!(event.to_packet(), packet);
311    }
312
313    #[test]
314    fn start_firmware_upgrade_try_from_packet_test() {
315        let mut packet = EVENT_PACKET;
316        packet.data = vec![
317            ((PROGRAMMER_START_FIRMWARE_UPGRADE_EVENT_CODE >> 8) & 0xff) as u8, // event code
318            ((PROGRAMMER_START_FIRMWARE_UPGRADE_EVENT_CODE >> 0) & 0xff) as u8, // event code
319            0x01, // programmer address
320            0x23, // programmer address
321            0x01, // firmware size
322            0x23, // firmware size
323            0x45, // firmware size
324            0x67, // firmware size
325        ];
326
327        let event = ProgrammerStartFirmwareUpgradeEvent::try_from_packet(&packet).unwrap();
328
329        assert_eq!(event.receiver_address, 0xabab);
330        assert_eq!(event.programmer_address, 0x0123);
331        assert_eq!(event.firmware_size, 0x01234567);
332    }
333
334    #[test]
335    fn start_firmware_upgrade_to_packet_test() {
336        let event = ProgrammerStartFirmwareUpgradeEvent {
337            receiver_address: 0xabab,
338            programmer_address: 0x0123,
339            firmware_size: 0x01234567,
340        };
341
342        let mut packet = EVENT_PACKET;
343        packet.data = vec![
344            ((PROGRAMMER_START_FIRMWARE_UPGRADE_EVENT_CODE >> 8) & 0xff) as u8, // event code
345            ((PROGRAMMER_START_FIRMWARE_UPGRADE_EVENT_CODE >> 0) & 0xff) as u8, // event code
346            0x01, // programmer address
347            0x23, // programmer address
348            0x01, // firmware size
349            0x23, // firmware size
350            0x45, // firmware size
351            0x67, // firmware size
352        ];
353
354        assert_eq!(event.to_packet(), packet);
355    }
356
357    #[test]
358    fn start_config_upgrade_try_from_packet_test() {
359        let mut packet = EVENT_PACKET;
360        packet.data = vec![
361            ((PROGRAMMER_START_CONFIG_UPGRADE_EVENT_CODE >> 8) & 0xff) as u8, // event code
362            ((PROGRAMMER_START_CONFIG_UPGRADE_EVENT_CODE >> 0) & 0xff) as u8, // event code
363            0x01,                                                             // programmer address
364            0x23,                                                             // programmer address
365            0x01,                                                             // data len
366            0x23,                                                             // data len
367            0x45,                                                             // data len
368            0x67,                                                             // data len
369        ];
370
371        let event = ProgrammerStartConfigUpgradeEvent::try_from_packet(&packet).unwrap();
372
373        assert_eq!(event.receiver_address, 0xabab);
374        assert_eq!(event.programmer_address, 0x0123);
375        assert_eq!(event.config_size, 0x01234567);
376    }
377
378    #[test]
379    fn start_config_upgrade_to_packet_test() {
380        let event = ProgrammerStartConfigUpgradeEvent {
381            receiver_address: 0xabab,
382            programmer_address: 0x0123,
383            config_size: 0x01234567,
384        };
385
386        let mut packet = EVENT_PACKET;
387        packet.data = vec![
388            ((PROGRAMMER_START_CONFIG_UPGRADE_EVENT_CODE >> 8) & 0xff) as u8, // event code
389            ((PROGRAMMER_START_CONFIG_UPGRADE_EVENT_CODE >> 0) & 0xff) as u8, // event code
390            0x01,                                                             // programmer address
391            0x23,                                                             // programmer address
392            0x01,                                                             // data len
393            0x23,                                                             // data len
394            0x45,                                                             // data len
395            0x67,                                                             // data len
396        ];
397
398        assert_eq!(event.to_packet(), packet);
399    }
400
401    #[test]
402    fn set_device_address_try_from_packet_test() {
403        let mut packet = EVENT_PACKET;
404        packet.data = vec![
405            ((PROGRAMMER_SET_DEVICE_ADDRESS_EVENT_CODE >> 8) & 0xff) as u8, // event code
406            ((PROGRAMMER_SET_DEVICE_ADDRESS_EVENT_CODE >> 0) & 0xff) as u8, // event code
407            0x01,                                                           // programmer address
408            0x23,                                                           // programmer address
409            0x01,                                                           // new address
410            0x23,                                                           // new address
411        ];
412
413        let event = ProgrammerSetDeviceAddressEvent::try_from_packet(&packet).unwrap();
414
415        assert_eq!(event.receiver_address, 0xabab);
416        assert_eq!(event.programmer_address, 0x0123);
417        assert_eq!(event.new_address, 0x0123);
418    }
419
420    #[test]
421    fn set_device_address_to_packet_test() {
422        let event = ProgrammerSetDeviceAddressEvent {
423            receiver_address: 0xabab,
424            programmer_address: 0x0123,
425            new_address: 0x0123,
426        };
427
428        let mut packet = EVENT_PACKET;
429        packet.data = vec![
430            ((PROGRAMMER_SET_DEVICE_ADDRESS_EVENT_CODE >> 8) & 0xff) as u8, // event code
431            ((PROGRAMMER_SET_DEVICE_ADDRESS_EVENT_CODE >> 0) & 0xff) as u8, // event code
432            0x01,                                                           // programmer address
433            0x23,                                                           // programmer address
434            0x01,                                                           // new address
435            0x23,                                                           // new address
436        ];
437
438        assert_eq!(event.to_packet(), packet);
439    }
440}
ross_protocol/event/programmer.rs

ross_protocol/event/
programmer.rs
