Port FDCAN HAL to use PAC directly instead of fdcan crate.

- Provide separate FDCAN capable and Classic CAN API's
- Don't use fdcan crate dep anymore
- Provide embedded-can traits.

2 files changed, 29 insertions, 81 deletions

diff --git a/tests/stm32/Cargo.toml b/tests/stm32/Cargo.toml
index 8554682a4..5b28b5849 100644
--- a/tests/stm32/Cargo.toml
+++ b/tests/stm32/Cargo.toml
@@ -69,6 +69,7 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
+embedded-can = { version = "0.4" }
 micromath = "2.0.0"
 panic-probe = { version = "0.3.0", features = ["print-defmt"] }
 rand_core = { version = "0.6", default-features = false }
diff --git a/tests/stm32/src/bin/fdcan.rs b/tests/stm32/src/bin/fdcan.rs
index 7363eaa16..76c27d091 100644
--- a/tests/stm32/src/bin/fdcan.rs
+++ b/tests/stm32/src/bin/fdcan.rs
@@ -36,7 +36,7 @@ fn options() -> TestOptions {
     c.rcc.fdcan_clock_source = rcc::FdCanClockSource::HSE;
     TestOptions {
         config: c,
-        max_latency: Duration::from_micros(3800),
+        max_latency: Duration::from_micros(1200),
         second_fifo_working: false,
     }
 }
@@ -53,12 +53,12 @@ fn options() -> TestOptions {
     c.rcc.fdcan_clock_source = rcc::FdCanClockSource::HSE;
     TestOptions {
         config: c,
-        max_latency: Duration::from_micros(5500),
+        max_latency: Duration::from_micros(1200),
         second_fifo_working: false,
     }
 }
 
-#[cfg(any(feature = "stm32g491re"))]
+#[cfg(any(feature = "stm32g491re", feature = "stm32g431cb"))]
 fn options() -> TestOptions {
     info!("G4 config");
     TestOptions {
@@ -80,9 +80,9 @@ async fn main(_spawner: Spawner) {
     // 250k bps
     can.set_bitrate(250_000);
 
-    can.can.set_extended_filter(
-        can::filter::ExtendedFilterSlot::_0,
-        can::filter::ExtendedFilter::accept_all_into_fifo1(),
+    can.set_extended_filter(
+        can::fd::filter::ExtendedFilterSlot::_0,
+        can::fd::filter::ExtendedFilter::accept_all_into_fifo1(),
     );
 
     let mut can = can.into_internal_loopback_mode();
@@ -91,31 +91,21 @@ async fn main(_spawner: Spawner) {
 
     let mut i: u8 = 0;
     loop {
-        let tx_frame = can::TxFrame::new(
-            can::TxFrameHeader {
-                len: 1,
-                frame_format: can::FrameFormat::Standard,
-                id: can::StandardId::new(0x123).unwrap().into(),
-                bit_rate_switching: false,
-                marker: None,
-            },
-            &[i],
-        )
-        .unwrap();
+        let tx_frame = can::frame::ClassicFrame::new_standard(0x123, &[i; 1]).unwrap();
 
         info!("Transmitting frame...");
         let tx_ts = Instant::now();
         can.write(&tx_frame).await;
 
-        let envelope = can.read().await.unwrap();
+        let (frame, timestamp) = can.read().await.unwrap();
         info!("Frame received!");
 
         // Check data.
-        assert!(i == envelope.data()[0], "{} == {}", i, envelope.data()[0]);
+        assert!(i == frame.data()[0], "{} == {}", i, frame.data()[0]);
 
-        info!("loopback time {}", envelope.header.time_stamp);
-        info!("loopback frame {=u8}", envelope.data()[0]);
-        let latency = envelope.timestamp.saturating_duration_since(tx_ts);
+        info!("loopback time {}", timestamp);
+        info!("loopback frame {=u8}", frame.data()[0]);
+        let latency = timestamp.saturating_duration_since(tx_ts);
         info!("loopback latency {} us", latency.as_micros());
 
         // Theoretical minimum latency is 55us, actual is usually ~80us
@@ -143,47 +133,26 @@ async fn main(_spawner: Spawner) {
     // in each FIFO so make sure we write enough to fill them both up before reading.
     for i in 0..3 {
         // Try filling up the RX FIFO0 buffers with standard packets
-        let tx_frame = can::TxFrame::new(
-            can::TxFrameHeader {
-                len: 1,
-                frame_format: can::FrameFormat::Standard,
-                id: can::StandardId::new(0x123).unwrap().into(),
-                bit_rate_switching: false,
-                marker: None,
-            },
-            &[i],
-        )
-        .unwrap();
+        let tx_frame = can::frame::ClassicFrame::new_standard(0x123, &[i; 1]).unwrap();
         info!("Transmitting frame {}", i);
         can.write(&tx_frame).await;
     }
     for i in 3..max_buffered {
         // Try filling up the RX FIFO0 buffers with extended packets
-        let tx_frame = can::TxFrame::new(
-            can::TxFrameHeader {
-                len: 1,
-                frame_format: can::FrameFormat::Standard,
-                id: can::ExtendedId::new(0x1232344).unwrap().into(),
-                bit_rate_switching: false,
-                marker: None,
-            },
-            &[i],
-        )
-        .unwrap();
-
+        let tx_frame = can::frame::ClassicFrame::new_extended(0x1232344, &[i; 1]).unwrap();
         info!("Transmitting frame {}", i);
         can.write(&tx_frame).await;
     }
 
     // Try and receive all 6 packets
     for i in 0..max_buffered {
-        let envelope = can.read().await.unwrap();
-        match envelope.header.id {
-            can::Id::Extended(id) => {
-                info!("Extended received! {:x} {} {}", id.as_raw(), envelope.data()[0], i);
+        let (frame, _ts) = can.read().await.unwrap();
+        match frame.id() {
+            embedded_can::Id::Extended(id) => {
+                info!("Extended received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
             }
-            can::Id::Standard(id) => {
-                info!("Standard received! {:x} {} {}", id.as_raw(), envelope.data()[0], i);
+            embedded_can::Id::Standard(id) => {
+                info!("Standard received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
             }
         }
     }
@@ -192,48 +161,26 @@ async fn main(_spawner: Spawner) {
     let (mut tx, mut rx) = can.split();
     for i in 0..3 {
         // Try filling up the RX FIFO0 buffers with standard packets
-        let tx_frame = can::TxFrame::new(
-            can::TxFrameHeader {
-                len: 1,
-                frame_format: can::FrameFormat::Standard,
-                id: can::StandardId::new(0x123).unwrap().into(),
-                bit_rate_switching: false,
-                marker: None,
-            },
-            &[i],
-        )
-        .unwrap();
-
+        let tx_frame = can::frame::ClassicFrame::new_standard(0x123, &[i; 1]).unwrap();
         info!("Transmitting frame {}", i);
         tx.write(&tx_frame).await;
     }
     for i in 3..max_buffered {
         // Try filling up the RX FIFO0 buffers with extended packets
-        let tx_frame = can::TxFrame::new(
-            can::TxFrameHeader {
-                len: 1,
-                frame_format: can::FrameFormat::Standard,
-                id: can::ExtendedId::new(0x1232344).unwrap().into(),
-                bit_rate_switching: false,
-                marker: None,
-            },
-            &[i],
-        )
-        .unwrap();
-
+        let tx_frame = can::frame::ClassicFrame::new_extended(0x1232344, &[i; 1]).unwrap();
         info!("Transmitting frame {}", i);
         tx.write(&tx_frame).await;
     }
 
     // Try and receive all 6 packets
     for i in 0..max_buffered {
-        let envelope = rx.read().await.unwrap();
-        match envelope.header.id {
-            can::Id::Extended(id) => {
-                info!("Extended received! {:x} {} {}", id.as_raw(), envelope.data()[0], i);
+        let (frame, _ts) = rx.read().await.unwrap();
+        match frame.id() {
+            embedded_can::Id::Extended(id) => {
+                info!("Extended received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
             }
-            can::Id::Standard(id) => {
-                info!("Standard received! {:x} {} {}", id.as_raw(), envelope.data()[0], i);
+            embedded_can::Id::Standard(id) => {
+                info!("Standard received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
             }
         }
     }