peak_can/
df.rs

1//! Data flow specific CAN-bus configurations.
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/* MessageFilter traits */
12
13pub(crate) trait HasMessageFilter {}
14
15pub trait MessageFilter {
16    fn is_open_filter(&self) -> Result<bool, CanError>;
17    fn is_closed_filter(&self) -> Result<bool, CanError>;
18}
19
20impl<T: HasMessageFilter + Channel> MessageFilter for T {
21    fn is_open_filter(&self) -> Result<bool, CanError> {
22        let mut data = [0u8; 4];
23        let code = unsafe {
24            peak_lib()?.CAN_GetValue(
25                self.channel(),
26                peak_can::PEAK_MESSAGE_FILTER as u8,
27                data.as_mut_ptr() as *mut c_void,
28                data.len() as u32,
29            )
30        };
31
32        match CanOkError::try_from(code) {
33            Ok(CanOkError::Ok) => {
34                if u32::from_le_bytes(data) == peak_can::PEAK_FILTER_OPEN {
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    fn is_closed_filter(&self) -> Result<bool, CanError> {
46        let mut data = [0u8; 4];
47        let code = unsafe {
48            peak_lib()?.CAN_GetValue(
49                self.channel(),
50                peak_can::PEAK_MESSAGE_FILTER as u8,
51                data.as_mut_ptr() as *mut c_void,
52                data.len() as u32,
53            )
54        };
55
56        match CanOkError::try_from(code) {
57            Ok(CanOkError::Ok) => {
58                if u32::from_le_bytes(data) == peak_can::PEAK_FILTER_CLOSE {
59                    Ok(true)
60                } else {
61                    Ok(false)
62                }
63            }
64            Ok(CanOkError::Err(err)) => Err(err),
65            Err(_) => Err(CanError::Unknown),
66        }
67    }
68}
69
70pub(crate) trait HasSetMessageFilter {}
71
72pub trait SetMessageFilter {
73    fn set_open_filter(&self) -> Result<(), CanError>;
74    fn set_closed_filter(&self) -> Result<(), CanError>;
75}
76
77impl<T: HasSetMessageFilter + Channel> SetMessageFilter for T {
78    fn set_open_filter(&self) -> Result<(), CanError> {
79        let mut data = peak_can::PEAK_FILTER_OPEN.to_le_bytes();
80        let code = unsafe {
81            peak_lib()?.CAN_SetValue(
82                self.channel(),
83                peak_can::PEAK_MESSAGE_FILTER as u8,
84                data.as_mut_ptr() as *mut c_void,
85                data.len() as u32,
86            )
87        };
88
89        match CanOkError::try_from(code) {
90            Ok(CanOkError::Ok) => Ok(()),
91            Ok(CanOkError::Err(err)) => Err(err),
92            Err(_) => Err(CanError::Unknown),
93        }
94    }
95
96    fn set_closed_filter(&self) -> Result<(), CanError> {
97        let mut data = peak_can::PEAK_FILTER_CLOSE.to_le_bytes();
98        let code = unsafe {
99            peak_lib()?.CAN_SetValue(
100                self.channel(),
101                peak_can::PEAK_MESSAGE_FILTER as u8,
102                data.as_mut_ptr() as *mut c_void,
103                data.len() as u32,
104            )
105        };
106
107        match CanOkError::try_from(code) {
108            Ok(CanOkError::Ok) => Ok(()),
109            Ok(CanOkError::Err(err)) => Err(err),
110            Err(_) => Err(CanError::Unknown),
111        }
112    }
113}
114
115/* ReceiveStatus traits */
116
117pub(crate) trait HasReceiveStatus {}
118
119pub trait ReceiveStatus {
120    fn is_receiving(&self) -> Result<bool, CanError>;
121}
122
123impl<T: HasReceiveStatus + Channel> ReceiveStatus for T {
124    fn is_receiving(&self) -> Result<bool, CanError> {
125        let mut data = [0u8; 4];
126        let code = unsafe {
127            peak_lib()?.CAN_GetValue(
128                self.channel(),
129                peak_can::PEAK_RECEIVE_STATUS as u8,
130                data.as_mut_ptr() as *mut c_void,
131                data.len() as u32,
132            )
133        };
134
135        match CanOkError::try_from(code) {
136            Ok(CanOkError::Ok) => {
137                let code = u32::from_le_bytes(data);
138                if code == peak_can::PEAK_PARAMETER_ON {
139                    Ok(true)
140                } else if code == peak_can::PEAK_PARAMETER_OFF {
141                    Ok(false)
142                } else {
143                    Err(CanError::Unknown)
144                }
145            }
146            Ok(CanOkError::Err(err)) => Err(err),
147            Err(_) => Err(CanError::Unknown),
148        }
149    }
150}
151
152pub(crate) trait HasSetReceiveStatus {}
153
154pub trait SetReceiveStatus {
155    fn set_receiving(&self, status: bool) -> Result<(), CanError>;
156}
157
158impl<T: HasSetReceiveStatus + Channel> SetReceiveStatus for T {
159    fn set_receiving(&self, status: bool) -> Result<(), CanError> {
160        let mut data = match status {
161            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
162            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
163        };
164        let code = unsafe {
165            peak_lib()?.CAN_SetValue(
166                self.channel(),
167                peak_can::PEAK_RECEIVE_STATUS as u8,
168                data.as_mut_ptr() as *mut c_void,
169                data.len() as u32,
170            )
171        };
172
173        match CanOkError::try_from(code) {
174            Ok(CanOkError::Ok) => Ok(()),
175            Ok(CanOkError::Err(err)) => Err(err),
176            Err(_) => Err(CanError::Unknown),
177        }
178    }
179}
180
181/* ALLOW STATUS FRAMES traits */
182
183pub(crate) trait HasAllowStatusFrames {}
184
185pub trait AllowStatusFrames {
186    fn allows_status_frames(&self) -> Result<bool, CanError>;
187}
188
189impl<T: HasAllowStatusFrames + Channel> AllowStatusFrames for T {
190    fn allows_status_frames(&self) -> Result<bool, CanError> {
191        let mut data = [0u8; 4];
192        let code = unsafe {
193            peak_lib()?.CAN_GetValue(
194                self.channel(),
195                peak_can::PEAK_ALLOW_STATUS_FRAMES as u8,
196                data.as_mut_ptr() as *mut c_void,
197                data.len() as u32,
198            )
199        };
200
201        match CanOkError::try_from(code) {
202            Ok(CanOkError::Ok) => {
203                let code = u32::from_le_bytes(data);
204                if code == peak_can::PEAK_PARAMETER_ON {
205                    Ok(true)
206                } else if code == peak_can::PEAK_PARAMETER_OFF {
207                    Ok(false)
208                } else {
209                    Err(CanError::Unknown)
210                }
211            }
212            Ok(CanOkError::Err(err)) => Err(err),
213            Err(_) => Err(CanError::Unknown),
214        }
215    }
216}
217
218pub(crate) trait HasSetAllowStatusFrames {}
219
220pub trait SetAllowStatusFrames {
221    fn allow_status_frames(&self, enable: bool) -> Result<(), CanError>;
222}
223
224impl<T: HasSetAllowStatusFrames + Channel> SetAllowStatusFrames for T {
225    fn allow_status_frames(&self, enable: bool) -> Result<(), CanError> {
226        let mut data = match enable {
227            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
228            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
229        };
230        let code = unsafe {
231            peak_lib()?.CAN_SetValue(
232                self.channel(),
233                peak_can::PEAK_ALLOW_STATUS_FRAMES as u8,
234                data.as_mut_ptr() as *mut c_void,
235                data.len() as u32,
236            )
237        };
238
239        match CanOkError::try_from(code) {
240            Ok(CanOkError::Ok) => Ok(()),
241            Ok(CanOkError::Err(err)) => Err(err),
242            Err(_) => Err(CanError::Unknown),
243        }
244    }
245}
246
247/* ALLOW RTS FRAMES traits */
248
249pub(crate) trait HasAllowRTRFrames {}
250
251pub trait AllowRTRFrames {
252    fn allows_rtr_frames(&self) -> Result<bool, CanError>;
253}
254
255impl<T: HasAllowRTRFrames + Channel> AllowRTRFrames for T {
256    fn allows_rtr_frames(&self) -> Result<bool, CanError> {
257        let mut data = [0u8; 4];
258        let code = unsafe {
259            peak_lib()?.CAN_GetValue(
260                self.channel(),
261                peak_can::PEAK_ALLOW_RTR_FRAMES as u8,
262                data.as_mut_ptr() as *mut c_void,
263                data.len() as u32,
264            )
265        };
266
267        match CanOkError::try_from(code) {
268            Ok(CanOkError::Ok) => {
269                let code = u32::from_le_bytes(data);
270                if code == peak_can::PEAK_PARAMETER_ON {
271                    Ok(true)
272                } else if code == peak_can::PEAK_PARAMETER_OFF {
273                    Ok(false)
274                } else {
275                    Err(CanError::Unknown)
276                }
277            }
278            Ok(CanOkError::Err(err)) => Err(err),
279            Err(_) => Err(CanError::Unknown),
280        }
281    }
282}
283
284pub(crate) trait HasSetAllowRTRFrames {}
285
286pub trait SetAllowRTRFrames {
287    fn allow_rtr_frames(&self, enable: bool) -> Result<(), CanError>;
288}
289
290impl<T: HasSetAllowRTRFrames + Channel> SetAllowRTRFrames for T {
291    fn allow_rtr_frames(&self, enable: bool) -> Result<(), CanError> {
292        let mut data = match enable {
293            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
294            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
295        };
296        let code = unsafe {
297            peak_lib()?.CAN_SetValue(
298                self.channel(),
299                peak_can::PEAK_ALLOW_RTR_FRAMES as u8,
300                data.as_mut_ptr() as *mut c_void,
301                data.len() as u32,
302            )
303        };
304
305        match CanOkError::try_from(code) {
306            Ok(CanOkError::Ok) => Ok(()),
307            Ok(CanOkError::Err(err)) => Err(err),
308            Err(_) => Err(CanError::Unknown),
309        }
310    }
311}
312
313/* ALLOW ERROR FRAMES traits */
314
315pub(crate) trait HasAllowErrorFrames {}
316
317pub trait AllowErrorFrames {
318    fn allows_error_frames(&self) -> Result<bool, CanError>;
319}
320
321impl<T: HasAllowErrorFrames + Channel> AllowErrorFrames for T {
322    fn allows_error_frames(&self) -> Result<bool, CanError> {
323        let mut data = [0u8; 4];
324        let code = unsafe {
325            peak_lib()?.CAN_GetValue(
326                self.channel(),
327                peak_can::PEAK_ALLOW_ERROR_FRAMES as u8,
328                data.as_mut_ptr() as *mut c_void,
329                data.len() as u32,
330            )
331        };
332
333        match CanOkError::try_from(code) {
334            Ok(CanOkError::Ok) => {
335                let code = u32::from_le_bytes(data);
336                if code == peak_can::PEAK_PARAMETER_ON {
337                    Ok(true)
338                } else if code == peak_can::PEAK_PARAMETER_OFF {
339                    Ok(false)
340                } else {
341                    Err(CanError::Unknown)
342                }
343            }
344            Ok(CanOkError::Err(err)) => Err(err),
345            Err(_) => Err(CanError::Unknown),
346        }
347    }
348}
349
350pub(crate) trait HasSetAllowErrorFrames {}
351
352pub trait SetAllowErrorFrames {
353    fn allow_error_frames(&self, enable: bool) -> Result<(), CanError>;
354}
355
356impl<T: HasSetAllowErrorFrames + Channel> SetAllowErrorFrames for T {
357    fn allow_error_frames(&self, enable: bool) -> Result<(), CanError> {
358        let mut data = match enable {
359            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
360            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
361        };
362        let code = unsafe {
363            peak_lib()?.CAN_SetValue(
364                self.channel(),
365                peak_can::PEAK_ALLOW_ERROR_FRAMES as u8,
366                data.as_mut_ptr() as *mut c_void,
367                data.len() as u32,
368            )
369        };
370
371        match CanOkError::try_from(code) {
372            Ok(CanOkError::Ok) => Ok(()),
373            Ok(CanOkError::Err(err)) => Err(err),
374            Err(_) => Err(CanError::Unknown),
375        }
376    }
377}
378
379/* ALLOW ECHO FRAMES traits */
380
381pub(crate) trait HasAllowEchoFrames {}
382
383pub trait AllowEchoFrames {
384    fn allows_echo_frames(&self) -> Result<bool, CanError>;
385}
386
387impl<T: HasAllowEchoFrames + Channel> AllowEchoFrames for T {
388    fn allows_echo_frames(&self) -> Result<bool, CanError> {
389        let mut data = [0u8; 4];
390        let code = unsafe {
391            peak_lib()?.CAN_GetValue(
392                self.channel(),
393                peak_can::PEAK_ALLOW_ECHO_FRAMES as u8,
394                data.as_mut_ptr() as *mut c_void,
395                data.len() as u32,
396            )
397        };
398
399        match CanOkError::try_from(code) {
400            Ok(CanOkError::Ok) => {
401                let code = u32::from_le_bytes(data);
402                if code == peak_can::PEAK_PARAMETER_ON {
403                    Ok(true)
404                } else if code == peak_can::PEAK_PARAMETER_OFF {
405                    Ok(false)
406                } else {
407                    Err(CanError::Unknown)
408                }
409            }
410            Ok(CanOkError::Err(err)) => Err(err),
411            Err(_) => Err(CanError::Unknown),
412        }
413    }
414}
415
416pub(crate) trait HasSetAllowEchoFrames {}
417
418pub trait SetAllowEchoFrames {
419    fn allow_echo_frames(&self, enable: bool) -> Result<(), CanError>;
420}
421
422impl<T: HasSetAllowEchoFrames + Channel> SetAllowEchoFrames for T {
423    fn allow_echo_frames(&self, enable: bool) -> Result<(), CanError> {
424        let mut data = match enable {
425            true => peak_can::PEAK_PARAMETER_ON.to_le_bytes(),
426            false => peak_can::PEAK_PARAMETER_OFF.to_le_bytes(),
427        };
428        let code = unsafe {
429            peak_lib()?.CAN_SetValue(
430                self.channel(),
431                peak_can::PEAK_ALLOW_ECHO_FRAMES as u8,
432                data.as_mut_ptr() as *mut c_void,
433                data.len() as u32,
434            )
435        };
436
437        match CanOkError::try_from(code) {
438            Ok(CanOkError::Ok) => Ok(()),
439            Ok(CanOkError::Err(err)) => Err(err),
440            Err(_) => Err(CanError::Unknown),
441        }
442    }
443}
444
445/* ACCEPTANCE FILTER 11Bit traits */
446
447pub(crate) trait HasAcceptanceFilter11Bit {}
448
449pub trait AcceptanceFilter11Bit {
450    fn acceptance_filter_11bit(&self) -> Result<(u32, u32), CanError>;
451}
452
453impl<T: HasAcceptanceFilter11Bit + Channel> AcceptanceFilter11Bit for T {
454    fn acceptance_filter_11bit(&self) -> Result<(u32, u32), CanError> {
455        let mut data = [0u8; 8];
456        let code = unsafe {
457            peak_lib()?.CAN_GetValue(
458                self.channel(),
459                peak_can::PEAK_ACCEPTANCE_FILTER_11BIT as u8,
460                data.as_mut_ptr() as *mut c_void,
461                data.len() as u32,
462            )
463        };
464
465        match CanOkError::try_from(code) {
466            Ok(CanOkError::Ok) => {
467                let acceptance_mask = u32::from_le_bytes([data[0], data[1], data[2], data[3]]);
468                let acceptance_code = u32::from_le_bytes([data[4], data[5], data[6], data[7]]);
469                Ok((acceptance_mask, acceptance_code))
470            }
471            Ok(CanOkError::Err(err)) => Err(err),
472            Err(_) => Err(CanError::Unknown),
473        }
474    }
475}
476
477pub(crate) trait HasSetAcceptanceFilter11Bit {}
478
479pub trait SetAcceptanceFilter11Bit {
480    fn set_acceptance_filter_11bit(&self, ids: &[u32]) -> Result<(), CanError>;
481}
482
483impl<T: HasSetAcceptanceFilter11Bit + Channel> SetAcceptanceFilter11Bit for T {
484    fn set_acceptance_filter_11bit(&self, ids: &[u32]) -> Result<(), CanError> {
485        let acceptance_code = ids
486            .iter()
487            .map(|x| *x & 0x7_FFu32)
488            .fold(0xFF_FF_FF_FFu32, |x, y| x & y);
489        let acceptance_code_data = acceptance_code.to_le_bytes();
490
491        let acceptance_mask = ids.iter().map(|x| *x & 0x7_FFu32).fold(0u32, |x, y| x ^ y);
492        let acceptance_mask_data = acceptance_mask.to_le_bytes();
493
494        let mut data = [
495            acceptance_mask_data[0],
496            acceptance_mask_data[1],
497            acceptance_mask_data[2],
498            acceptance_mask_data[3],
499            acceptance_code_data[0],
500            acceptance_code_data[1],
501            acceptance_code_data[2],
502            acceptance_code_data[3],
503        ];
504        let code = unsafe {
505            peak_lib()?.CAN_SetValue(
506                self.channel(),
507                peak_can::PEAK_ACCEPTANCE_FILTER_11BIT as u8,
508                data.as_mut_ptr() as *mut c_void,
509                data.len() as u32,
510            )
511        };
512
513        match CanOkError::try_from(code) {
514            Ok(CanOkError::Ok) => Ok(()),
515            Ok(CanOkError::Err(err)) => Err(err),
516            Err(_) => Err(CanError::Unknown),
517        }
518    }
519}
520
521/* ACCEPTANCE FILTER 29Bit traits */
522
523pub(crate) trait HasAcceptanceFilter29Bit {}
524
525pub trait AcceptanceFilter29Bit {
526    fn acceptance_filter_29bit(&self) -> Result<(u32, u32), CanError>;
527}
528
529impl<T: HasAcceptanceFilter29Bit + Channel> AcceptanceFilter29Bit for T {
530    fn acceptance_filter_29bit(&self) -> Result<(u32, u32), CanError> {
531        let mut data = [0u8; 8];
532        let code = unsafe {
533            peak_lib()?.CAN_GetValue(
534                self.channel(),
535                peak_can::PEAK_ACCEPTANCE_FILTER_29BIT as u8,
536                data.as_mut_ptr() as *mut c_void,
537                data.len() as u32,
538            )
539        };
540
541        match CanOkError::try_from(code) {
542            Ok(CanOkError::Ok) => {
543                let acceptance_mask = u32::from_le_bytes([data[0], data[1], data[2], data[3]]);
544                let acceptance_code = u32::from_le_bytes([data[4], data[5], data[6], data[7]]);
545                Ok((acceptance_mask, acceptance_code))
546            }
547            Ok(CanOkError::Err(err)) => Err(err),
548            Err(_) => Err(CanError::Unknown),
549        }
550    }
551}
552
553pub(crate) trait HasSetAcceptanceFilter29Bit {}
554
555pub trait SetAcceptanceFilter29Bit {
556    fn set_acceptance_filter_29bit(&self, ids: &[u32]) -> Result<(), CanError>;
557}
558
559impl<T: HasSetAcceptanceFilter29Bit + Channel> SetAcceptanceFilter29Bit for T {
560    fn set_acceptance_filter_29bit(&self, ids: &[u32]) -> Result<(), CanError> {
561        let acceptance_code = ids
562            .iter()
563            .map(|x| *x & 0x1F_FF_FF_FFu32)
564            .fold(0xFF_FF_FF_FFu32, |x, y| x & y);
565        let acceptance_code_data = acceptance_code.to_le_bytes();
566
567        let acceptance_mask = ids
568            .iter()
569            .map(|x| *x & 0x1F_FF_FF_FFu32)
570            .fold(0u32, |x, y| x ^ y);
571        let acceptance_mask_data = acceptance_mask.to_le_bytes();
572
573        let mut data = [
574            acceptance_mask_data[0],
575            acceptance_mask_data[1],
576            acceptance_mask_data[2],
577            acceptance_mask_data[3],
578            acceptance_code_data[0],
579            acceptance_code_data[1],
580            acceptance_code_data[2],
581            acceptance_code_data[3],
582        ];
583        let code = unsafe {
584            peak_lib()?.CAN_SetValue(
585                self.channel(),
586                peak_can::PEAK_ACCEPTANCE_FILTER_29BIT as u8,
587                data.as_mut_ptr() as *mut c_void,
588                data.len() as u32,
589            )
590        };
591
592        match CanOkError::try_from(code) {
593            Ok(CanOkError::Ok) => Ok(()),
594            Ok(CanOkError::Err(err)) => Err(err),
595            Err(_) => Err(CanError::Unknown),
596        }
597    }
598}
peak_can/df.rs

peak_can/
df.rs
