ross_protocol/event/
button.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;
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
10pub struct ButtonPressedEvent {
11    pub receiver_address: u16,
12    pub button_address: u16,
13    pub index: u8,
14}
15
16impl ConvertPacket<ButtonPressedEvent> for ButtonPressedEvent {
17    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
18        if packet.data.len() != 5 {
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()) != BUTTON_PRESSED_EVENT_CODE {
27            return Err(ConvertPacketError::Event(EventError::WrongEventType));
28        }
29
30        let receiver_address = packet.device_address;
31        let button_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
32        let index = packet.data[4];
33
34        Ok(ButtonPressedEvent {
35            receiver_address,
36            button_address,
37            index,
38        })
39    }
40
41    fn to_packet(&self) -> Packet {
42        let mut data = vec![];
43
44        for byte in u16::to_be_bytes(BUTTON_PRESSED_EVENT_CODE).iter() {
45            data.push(*byte);
46        }
47
48        for byte in u16::to_be_bytes(self.button_address).iter() {
49            data.push(*byte);
50        }
51
52        data.push(self.index);
53
54        Packet {
55            is_error: false,
56            device_address: self.receiver_address,
57            data,
58        }
59    }
60}
61
62#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
63pub struct ButtonReleasedEvent {
64    pub receiver_address: u16,
65    pub button_address: u16,
66    pub index: u8,
67}
68
69impl ConvertPacket<ButtonReleasedEvent> for ButtonReleasedEvent {
70    fn try_from_packet(packet: &Packet) -> Result<Self, ConvertPacketError> {
71        if packet.data.len() != 5 {
72            return Err(ConvertPacketError::WrongSize);
73        }
74
75        if packet.is_error {
76            return Err(ConvertPacketError::WrongType);
77        }
78
79        if u16::from_be_bytes(packet.data[0..=1].try_into().unwrap()) != BUTTON_RELEASED_EVENT_CODE
80        {
81            return Err(ConvertPacketError::Event(EventError::WrongEventType));
82        }
83
84        let receiver_address = packet.device_address;
85        let button_address = u16::from_be_bytes(packet.data[2..=3].try_into().unwrap());
86        let index = packet.data[4];
87
88        Ok(ButtonReleasedEvent {
89            receiver_address,
90            button_address,
91            index,
92        })
93    }
94
95    fn to_packet(&self) -> Packet {
96        let mut data = vec![];
97
98        for byte in u16::to_be_bytes(BUTTON_RELEASED_EVENT_CODE).iter() {
99            data.push(*byte);
100        }
101
102        for byte in u16::to_be_bytes(self.button_address).iter() {
103            data.push(*byte);
104        }
105
106        data.push(self.index);
107
108        Packet {
109            is_error: false,
110            device_address: self.receiver_address,
111            data,
112        }
113    }
114}
115
116#[cfg(test)]
117mod tests {
118    use super::*;
119
120    const EVENT_PACKET: Packet = Packet {
121        is_error: false,
122        device_address: 0xabab,
123        data: vec![],
124    };
125
126    #[test]
127    fn pressed_try_from_packet_test() {
128        let mut packet = EVENT_PACKET;
129        packet.data = vec![
130            ((BUTTON_PRESSED_EVENT_CODE >> 8) & 0xff) as u8, // event code
131            ((BUTTON_PRESSED_EVENT_CODE >> 0) & 0xff) as u8, // event code
132            0x01,                                            // button address
133            0x23,                                            // button address
134            0x45,                                            // index
135        ];
136
137        let event = ButtonPressedEvent::try_from_packet(&packet).unwrap();
138
139        assert_eq!(event.receiver_address, 0xabab);
140        assert_eq!(event.button_address, 0x0123);
141        assert_eq!(event.index, 0x45);
142    }
143
144    #[test]
145    fn pressed_to_packet_test() {
146        let event = ButtonPressedEvent {
147            receiver_address: 0xabab,
148            button_address: 0x0123,
149            index: 0x45,
150        };
151
152        let mut packet = EVENT_PACKET;
153        packet.data = vec![
154            ((BUTTON_PRESSED_EVENT_CODE >> 8) & 0xff) as u8, // event code
155            ((BUTTON_PRESSED_EVENT_CODE >> 0) & 0xff) as u8, // event code
156            0x01,                                            // button address
157            0x23,                                            // button address
158            0x45,                                            // index
159        ];
160
161        assert_eq!(event.to_packet(), packet);
162    }
163
164    #[test]
165    fn released_try_from_test() {
166        let mut packet = EVENT_PACKET;
167        packet.data = vec![
168            ((BUTTON_RELEASED_EVENT_CODE >> 8) & 0xff) as u8, // event code
169            ((BUTTON_RELEASED_EVENT_CODE >> 0) & 0xff) as u8, // event code
170            0x01,                                             // button address
171            0x23,                                             // button address
172            0x45,                                             // index
173        ];
174
175        let event = ButtonReleasedEvent::try_from_packet(&packet).unwrap();
176
177        assert_eq!(event.receiver_address, 0xabab);
178        assert_eq!(event.button_address, 0x0123);
179        assert_eq!(event.index, 0x45);
180    }
181
182    #[test]
183    fn released_to_packet_test() {
184        let event = ButtonReleasedEvent {
185            receiver_address: 0xabab,
186            button_address: 0x0123,
187            index: 0x45,
188        };
189
190        let mut packet = EVENT_PACKET;
191        packet.data = vec![
192            ((BUTTON_RELEASED_EVENT_CODE >> 8) & 0xff) as u8, // event code
193            ((BUTTON_RELEASED_EVENT_CODE >> 0) & 0xff) as u8, // event code
194            0x01,                                             // button address
195            0x23,                                             // button address
196            0x45,                                             // index
197        ];
198
199        assert_eq!(event.to_packet(), packet);
200    }
201}
ross_protocol/event/button.rs

ross_protocol/event/
button.rs
