peak_can/
special.rs

1//!
2//!
3//!
4
5use crate::channel::Channel;
6use crate::error::{CanError, CanOkError};
7use crate::peak_lib;
8use crate::peak_can;
9use std::ffi::c_void;
10
11/* Five Volts Power */
12
13pub(crate) trait HasFiveVoltsPower {}
14
15pub trait FiveVoltsPower {
16    fn five_volts(&self) -> Result<bool, CanError>;
17}
18
19impl<T: HasFiveVoltsPower + Channel> FiveVoltsPower for T {
20    fn five_volts(&self) -> Result<bool, CanError> {
21        let mut data = [0u8; 4];
22        let code = unsafe {
23            peak_lib()?.CAN_GetValue(
24                self.channel(),
25                peak_can::PEAK_5VOLTS_POWER as u8,
26                data.as_mut_ptr() as *mut c_void,
27                data.len() as u32,
28            )
29        };
30
31        match CanOkError::try_from(code) {
32            Ok(CanOkError::Ok) => {
33                let value = u32::from_le_bytes(data);
34                if value & peak_can::PEAK_PARAMETER_ON == peak_can::PEAK_PARAMETER_ON {
35                    Ok(true)
36                } else {
37                    Ok(false)
38                }
39            }
40            Ok(CanOkError::Err(err)) => Err(err),
41            Err(_) => Err(CanError::Unknown),
42        }
43    }
44}
45
46pub(crate) trait HasSetFiveVoltsPower {}
47
48pub trait SetFiveVoltsPower {
49    fn set_five_volts(&self, value: bool) -> Result<(), CanError>;
50}
51
52impl<T: HasSetFiveVoltsPower + Channel> SetFiveVoltsPower for T {
53    fn set_five_volts(&self, value: bool) -> Result<(), CanError> {
54        let mut data = match value {
55            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
56            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
57        };
58        let code = unsafe {
59            peak_lib()?.CAN_SetValue(
60                self.channel(),
61                peak_can::PEAK_5VOLTS_POWER as u8,
62                data.as_mut_ptr() as *mut c_void,
63                data.len() as u32,
64            )
65        };
66
67        match CanOkError::try_from(code) {
68            Ok(CanOkError::Ok) => Ok(()),
69            Ok(CanOkError::Err(err)) => Err(err),
70            Err(_) => Err(CanError::Unknown),
71        }
72    }
73}
74
75/* Bus Off Autoreset */
76
77pub(crate) trait HasBusOffAutoreset {}
78
79pub trait BusOffAutoreset {
80    fn bus_off_autoreset(&self) -> Result<bool, CanError>;
81}
82
83impl<T: HasBusOffAutoreset + Channel> BusOffAutoreset for T {
84    fn bus_off_autoreset(&self) -> Result<bool, CanError> {
85        let mut data = [0u8; 4];
86        let code = unsafe {
87            peak_lib()?.CAN_GetValue(
88                self.channel(),
89                peak_can::PEAK_BUSOFF_AUTORESET as u8,
90                data.as_mut_ptr() as *mut c_void,
91                data.len() as u32,
92            )
93        };
94
95        match CanOkError::try_from(code) {
96            Ok(CanOkError::Ok) => {
97                let value = u32::from_le_bytes(data);
98                if value & peak_can::PEAK_PARAMETER_ON == peak_can::PEAK_PARAMETER_ON {
99                    Ok(true)
100                } else {
101                    Ok(false)
102                }
103            }
104            Ok(CanOkError::Err(err)) => Err(err),
105            Err(_) => Err(CanError::Unknown),
106        }
107    }
108}
109
110pub(crate) trait HasSetBusOffAutoreset {}
111
112pub trait SetBusOffAutoreset {
113    fn set_bus_off_autoreset(&self, value: bool) -> Result<(), CanError>;
114}
115
116impl<T: HasSetBusOffAutoreset + Channel> SetBusOffAutoreset for T {
117    fn set_bus_off_autoreset(&self, value: bool) -> Result<(), CanError> {
118        let mut data = match value {
119            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
120            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
121        };
122        let code = unsafe {
123            peak_lib()?.CAN_SetValue(
124                self.channel(),
125                peak_can::PEAK_BUSOFF_AUTORESET as u8,
126                data.as_mut_ptr() as *mut c_void,
127                data.len() as u32,
128            )
129        };
130
131        match CanOkError::try_from(code) {
132            Ok(CanOkError::Ok) => Ok(()),
133            Ok(CanOkError::Err(err)) => Err(err),
134            Err(_) => Err(CanError::Unknown),
135        }
136    }
137}
138
139/* Listen Only */
140
141pub(crate) trait HasListenOnly {}
142
143pub trait ListenOnly {
144    fn listen_only(&self) -> Result<bool, CanError>;
145}
146
147impl<T: HasListenOnly + Channel> ListenOnly for T {
148    fn listen_only(&self) -> Result<bool, CanError> {
149        let mut data = [0u8; 4];
150        let code = unsafe {
151            peak_lib()?.CAN_GetValue(
152                self.channel(),
153                peak_can::PEAK_LISTEN_ONLY as u8,
154                data.as_mut_ptr() as *mut c_void,
155                data.len() as u32,
156            )
157        };
158
159        match CanOkError::try_from(code) {
160            Ok(CanOkError::Ok) => {
161                let value = u32::from_le_bytes(data);
162                if value & peak_can::PEAK_PARAMETER_ON == peak_can::PEAK_PARAMETER_ON {
163                    Ok(true)
164                } else {
165                    Ok(false)
166                }
167            }
168            Ok(CanOkError::Err(err)) => Err(err),
169            Err(_) => Err(CanError::Unknown),
170        }
171    }
172}
173
174pub(crate) trait HasSetListenOnly {}
175
176pub trait SetListenOnly {
177    fn set_listen_only(&self, value: bool) -> Result<(), CanError>;
178}
179
180impl<T: HasSetListenOnly + Channel> SetListenOnly for T {
181    fn set_listen_only(&self, value: bool) -> Result<(), CanError> {
182        let mut data = match value {
183            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
184            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
185        };
186        let code = unsafe {
187            peak_lib()?.CAN_SetValue(
188                self.channel(),
189                peak_can::PEAK_LISTEN_ONLY as u8,
190                data.as_mut_ptr() as *mut c_void,
191                data.len() as u32,
192            )
193        };
194
195        match CanOkError::try_from(code) {
196            Ok(CanOkError::Ok) => Ok(()),
197            Ok(CanOkError::Err(err)) => Err(err),
198            Err(_) => Err(CanError::Unknown),
199        }
200    }
201}
202
203/* Bitrate Adapting */
204
205pub(crate) trait HasBitrateAdapting {}
206
207pub trait BitrateAdapting {
208    fn bitrate_adapting(&self) -> Result<bool, CanError>;
209}
210
211impl<T: HasBitrateAdapting + Channel> BitrateAdapting for T {
212    fn bitrate_adapting(&self) -> Result<bool, CanError> {
213        let mut data = [0u8; 4];
214        let code = unsafe {
215            peak_lib()?.CAN_GetValue(
216                self.channel(),
217                peak_can::PEAK_BITRATE_ADAPTING as u8,
218                data.as_mut_ptr() as *mut c_void,
219                data.len() as u32,
220            )
221        };
222
223        match CanOkError::try_from(code) {
224            Ok(CanOkError::Ok) => {
225                let value = u32::from_le_bytes(data);
226                if value & peak_can::PEAK_PARAMETER_ON == peak_can::PEAK_PARAMETER_ON {
227                    Ok(true)
228                } else {
229                    Ok(false)
230                }
231            }
232            Ok(CanOkError::Err(err)) => Err(err),
233            Err(_) => Err(CanError::Unknown),
234        }
235    }
236}
237
238pub(crate) trait HasSetBitrateAdapting {}
239
240pub trait SetBitrateAdapting {
241    fn set_bitrate_adapting(&self, value: bool) -> Result<(), CanError>;
242}
243
244impl<T: HasSetBitrateAdapting + Channel> SetBitrateAdapting for T {
245    fn set_bitrate_adapting(&self, value: bool) -> Result<(), CanError> {
246        let mut data = match value {
247            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
248            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
249        };
250        let code = unsafe {
251            peak_lib()?.CAN_SetValue(
252                self.channel(),
253                peak_can::PEAK_BITRATE_ADAPTING as u8,
254                data.as_mut_ptr() as *mut c_void,
255                data.len() as u32,
256            )
257        };
258
259        match CanOkError::try_from(code) {
260            Ok(CanOkError::Ok) => Ok(()),
261            Ok(CanOkError::Err(err)) => Err(err),
262            Err(_) => Err(CanError::Unknown),
263        }
264    }
265}
266
267/* Interframe Delay */
268
269pub(crate) trait HasInterframeDelay {}
270
271pub trait InterframeDelay {
272    fn interframe_delay(&self) -> Result<u32, CanError>;
273}
274
275impl<T: HasInterframeDelay + Channel> InterframeDelay for T {
276    fn interframe_delay(&self) -> Result<u32, CanError> {
277        let mut data = [0u8; 4];
278        let code = unsafe {
279            peak_lib()?.CAN_GetValue(
280                self.channel(),
281                peak_can::PEAK_INTERFRAME_DELAY as u8,
282                data.as_mut_ptr() as *mut c_void,
283                data.len() as u32,
284            )
285        };
286
287        match CanOkError::try_from(code) {
288            Ok(CanOkError::Ok) => Ok(u32::from_le_bytes(data)),
289            Ok(CanOkError::Err(err)) => Err(err),
290            Err(_) => Err(CanError::Unknown),
291        }
292    }
293}
294
295pub(crate) trait HasSetInterframeDelay {}
296
297pub trait SetInterframeDelay {
298    fn set_interframe_delay(&self, value: u32) -> Result<(), CanError>;
299}
300
301impl<T: HasSetInterframeDelay + Channel> SetInterframeDelay for T {
302    fn set_interframe_delay(&self, value: u32) -> Result<(), CanError> {
303        let mut data = value.to_le_bytes();
304        let code = unsafe {
305            peak_lib()?.CAN_SetValue(
306                self.channel(),
307                peak_can::PEAK_INTERFRAME_DELAY as u8,
308                data.as_mut_ptr() as *mut c_void,
309                data.len() as u32,
310            )
311        };
312
313        match CanOkError::try_from(code) {
314            Ok(CanOkError::Ok) => Ok(()),
315            Ok(CanOkError::Err(err)) => Err(err),
316            Err(_) => Err(CanError::Unknown),
317        }
318    }
319}
peak_can/special.rs

peak_can/
special.rs
