can: Add Id enum

With this addition the frame constructors are now fallible and return `Error` when
the identifier is out of range.

Author: timokroeger

examples/can-loopback.rs

@@ -10,7 +10,7 @@ use cortex_m_rt::entry;
 use embedded_hal::digital::v2::OutputPin;
 use nb::block;
 use stm32f1xx_hal::{
-    can::{Can, Filter, Frame},
+    can::{Can, Filter, Frame, Id},
     pac,
     prelude::*,
 };
@@ -59,21 +59,21 @@ fn main() -> ! {
 
     // 2x 11bit id + mask filter bank: Matches 0, 1, 2
     filters
-        .add(&Filter::new_standard(0).with_mask(!0b1))
+        .add(&Filter::new(Id::Standard(0)).with_mask(!0b1))
         .unwrap();
     filters
-        .add(&Filter::new_standard(0).with_mask(!0b10))
+        .add(&Filter::new(Id::Standard(0)).with_mask(!0b10))
         .unwrap();
 
     // 2x 29bit id filter bank: Matches 4, 5
-    filters.add(&Filter::new_standard(4)).unwrap();
-    filters.add(&Filter::new_standard(5)).unwrap();
+    filters.add(&Filter::new(Id::Standard(4))).unwrap();
+    filters.add(&Filter::new(Id::Standard(5))).unwrap();
 
     // 4x 11bit id filter bank: Matches 8, 9, 10, 11
-    filters.add(&Filter::new_standard(8)).unwrap();
-    filters.add(&Filter::new_standard(9)).unwrap();
-    filters.add(&Filter::new_standard(10)).unwrap();
-    filters.add(&Filter::new_standard(11)).unwrap();
+    filters.add(&Filter::new(Id::Standard(8))).unwrap();
+    filters.add(&Filter::new(Id::Standard(9))).unwrap();
+    filters.add(&Filter::new(Id::Standard(10))).unwrap();
+    filters.add(&Filter::new(Id::Standard(11))).unwrap();
 
     // Split the peripheral into transmitter and receiver parts.
     let mut rx = can.take_rx(filters).unwrap();
@@ -84,15 +84,15 @@ fn main() -> ! {
 
     // Some messages shall pass the filters.
     for &id in &[0, 1, 2, 4, 5, 8, 9, 10, 11] {
-        let frame_tx = Frame::new_standard(id, &[id as u8]);
+        let frame_tx = Frame::new(Id::Standard(id), &[id as u8]).unwrap();
         block!(tx.transmit(&frame_tx)).unwrap();
         let frame_rx = block!(rx.receive()).unwrap();
         assert_eq!(frame_tx, frame_rx);
     }
 
     // Others must be filtered out.
     for &id in &[3, 6, 7, 12] {
-        let frame_tx = Frame::new_standard(id, &[id as u8]);
+        let frame_tx = Frame::new(Id::Standard(id), &[id as u8]).unwrap();
         block!(tx.transmit(&frame_tx)).unwrap();
         assert!(rx.receive().is_err());
     }

examples/can-rtfm.rs

@@ -35,7 +35,7 @@ pool!(
 
 fn alloc_frame(id: Id, data: &[u8]) -> Box<CanFramePool, Init> {
     let frame_box = CanFramePool::alloc().unwrap();
-    frame_box.init(Frame::new(id, data))
+    frame_box.init(Frame::new(id, data).unwrap())
 }
 
 #[app(device = stm32f1xx_hal::pac, peripherals = true)]
@@ -90,10 +90,10 @@ const APP: () = {
         #[cfg(feature = "connectivity")]
         let (mut filters, _) = can.split_filters(0).unwrap();
         filters
-            .add(&Filter::new_standard(0).with_mask(0).allow_remote())
+            .add(&Filter::new(Id::Standard(0)).with_mask(0).allow_remote())
             .unwrap();
         filters
-            .add(&Filter::new_extended(0).with_mask(0).allow_remote())
+            .add(&Filter::new(Id::Extended(0)).with_mask(0).allow_remote())
             .unwrap();
 
         let mut can_rx = can.take_rx(filters).unwrap();
@@ -123,25 +123,25 @@ const APP: () = {
         // Enqueue some messages. Higher ID means lower priority.
         tx_queue.lock(|tx_queue| {
             tx_queue
-                .push(alloc_frame(Id::new_standard(9), &[0, 1, 2, 4]))
+                .push(alloc_frame(Id::Standard(9), &[0, 1, 2, 4]))
                 .unwrap();
             tx_queue
-                .push(alloc_frame(Id::new_standard(9), &[0, 1, 2, 4]))
+                .push(alloc_frame(Id::Standard(9), &[0, 1, 2, 4]))
                 .unwrap();
             tx_queue
-                .push(alloc_frame(Id::new_standard(8), &[0, 1, 2, 4]))
+                .push(alloc_frame(Id::Standard(8), &[0, 1, 2, 4]))
                 .unwrap();
 
             // Extended frames have lower priority than standard frames.
             tx_queue
-                .push(alloc_frame(Id::new_extended(8), &[0, 1, 2, 4]))
+                .push(alloc_frame(Id::Extended(8), &[0, 1, 2, 4]))
                 .unwrap();
             tx_queue
-                .push(alloc_frame(Id::new_extended(7), &[0, 1, 2, 4]))
+                .push(alloc_frame(Id::Extended(7), &[0, 1, 2, 4]))
                 .unwrap();
 
             tx_queue
-                .push(alloc_frame(Id::new_standard(7), &[0, 1, 2, 4]))
+                .push(alloc_frame(Id::Standard(7), &[0, 1, 2, 4]))
                 .unwrap();
         });
 
@@ -155,13 +155,13 @@ const APP: () = {
             if tx_count >= 3 {
                 tx_queue.lock(|tx_queue| {
                     tx_queue
-                        .push(alloc_frame(Id::new_standard(3), &[0, 1, 2, 4]))
+                        .push(alloc_frame(Id::Standard(3), &[0, 1, 2, 4]))
                         .unwrap();
                     tx_queue
-                        .push(alloc_frame(Id::new_standard(2), &[0, 1, 2, 4]))
+                        .push(alloc_frame(Id::Standard(2), &[0, 1, 2, 4]))
                         .unwrap();
                     tx_queue
-                        .push(alloc_frame(Id::new_standard(1), &[0, 1, 2, 4]))
+                        .push(alloc_frame(Id::Standard(1), &[0, 1, 2, 4]))
                         .unwrap();
                 });
                 break;