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.

4 files changed, 195 insertions, 80 deletions

diff --git a/examples/stm32g4/Cargo.toml b/examples/stm32g4/Cargo.toml
index 895ad3e7c..fdb325f06 100644
--- a/examples/stm32g4/Cargo.toml
+++ b/examples/stm32g4/Cargo.toml
@@ -20,6 +20,7 @@ defmt-rtt = "0.4"
 cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
+embedded-can = { version = "0.4" }
 panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.8", default-features = false }
diff --git a/examples/stm32g4/src/bin/can.rs b/examples/stm32g4/src/bin/can.rs
index 727921fba..5ff4f0ef0 100644
--- a/examples/stm32g4/src/bin/can.rs
+++ b/examples/stm32g4/src/bin/can.rs
@@ -20,32 +20,100 @@ async fn main(_spawner: Spawner) {
 
     let mut can = can::Fdcan::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs);
 
+    can.set_extended_filter(
+        can::fd::filter::ExtendedFilterSlot::_0,
+        can::fd::filter::ExtendedFilter::accept_all_into_fifo1(),
+    );
+
     // 250k bps
     can.set_bitrate(250_000);
 
+    // 1M bps
+    can.set_fd_data_bitrate(1_000_000, false);
+
     info!("Configured");
 
-    //let mut can = can.into_external_loopback_mode();
-    let mut can = can.into_normal_mode();
+    //let mut can = can.into_normal_mode();
+    let mut can = can.into_internal_loopback_mode();
 
     let mut i = 0;
+    let mut last_read_ts = embassy_time::Instant::now();
+
     loop {
-        let 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 frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
         info!("Writing frame");
+
         _ = can.write(&frame).await;
 
         match can.read().await {
-            Ok(rx_frame) => info!("Rx: {}", rx_frame.data()[0]),
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {} {:02x} --- {}ms",
+                    rx_frame.header().len(),
+                    rx_frame.data()[0..rx_frame.header().len() as usize],
+                    delta,
+                )
+            }
+            Err(_err) => error!("Error in frame"),
+        }
+
+        Timer::after_millis(250).await;
+
+        i += 1;
+        if i > 2 {
+            break;
+        }
+    }
+
+    // Use the FD API's even if we don't get FD packets.
+    loop {
+        let frame = can::frame::FdFrame::new_extended(0x123456F, &[i; 16]).unwrap();
+        info!("Writing frame using FD API");
+
+        _ = can.write_fd(&frame).await;
+
+        match can.read_fd().await {
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {} {:02x} --- using FD API {}ms",
+                    rx_frame.header().len(),
+                    rx_frame.data()[0..rx_frame.header().len() as usize],
+                    delta,
+                )
+            }
+            Err(_err) => error!("Error in frame"),
+        }
+
+        Timer::after_millis(250).await;
+
+        i += 1;
+        if i > 4 {
+            break;
+        }
+    }
+
+    let (mut tx, mut rx) = can.split();
+    // With split
+    loop {
+        let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
+        info!("Writing frame");
+        _ = tx.write(&frame).await;
+
+        match rx.read().await {
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {} {:02x} --- {}ms",
+                    rx_frame.header().len(),
+                    rx_frame.data()[0..rx_frame.header().len() as usize],
+                    delta,
+                )
+            }
             Err(_err) => error!("Error in frame"),
         }
 
diff --git a/examples/stm32h5/src/bin/can.rs b/examples/stm32h5/src/bin/can.rs
index 2906d1576..4b29a0d21 100644
--- a/examples/stm32h5/src/bin/can.rs
+++ b/examples/stm32h5/src/bin/can.rs
@@ -16,54 +16,77 @@ bind_interrupts!(struct Irqs {
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = Config::default();
-
-    // configure FDCAN to use PLL1_Q at 64 MHz
-    config.rcc.pll1 = Some(rcc::Pll {
-        source: rcc::PllSource::HSI,
-        prediv: rcc::PllPreDiv::DIV4,
-        mul: rcc::PllMul::MUL8,
-        divp: None,
-        divq: Some(rcc::PllDiv::DIV2),
-        divr: None,
+    config.rcc.hse = Some(rcc::Hse {
+        freq: embassy_stm32::time::Hertz(25_000_000),
+        mode: rcc::HseMode::Oscillator,
     });
-    config.rcc.fdcan_clock_source = rcc::FdCanClockSource::PLL1_Q;
+    config.rcc.fdcan_clock_source = rcc::FdCanClockSource::HSE;
 
     let peripherals = embassy_stm32::init(config);
 
+    //let mut can = can::Fdcan::new(peripherals.FDCAN1, peripherals.PB8, peripherals.PB9, Irqs);
     let mut can = can::Fdcan::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs);
 
-    can.can.apply_config(
-        can::config::FdCanConfig::default().set_nominal_bit_timing(can::config::NominalBitTiming {
-            sync_jump_width: 1.try_into().unwrap(),
-            prescaler: 8.try_into().unwrap(),
-            seg1: 13.try_into().unwrap(),
-            seg2: 2.try_into().unwrap(),
-        }),
-    );
+    // 250k bps
+    can.set_bitrate(250_000);
 
-    info!("Configured");
+    //let mut can = can.into_internal_loopback_mode();
+    let mut can = can.into_normal_mode();
 
-    let mut can = can.into_external_loopback_mode();
-    //let mut can = can.into_normal_mode();
+    info!("CAN Configured");
 
     let mut i = 0;
+    let mut last_read_ts = embassy_time::Instant::now();
+
     loop {
-        let 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 frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
         info!("Writing frame");
         _ = can.write(&frame).await;
 
         match can.read().await {
-            Ok(rx_frame) => info!("Rx: {}", rx_frame.data()[0]),
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {:x} {:x} {:x} {:x} --- NEW {}",
+                    rx_frame.data()[0],
+                    rx_frame.data()[1],
+                    rx_frame.data()[2],
+                    rx_frame.data()[3],
+                    delta,
+                )
+            }
+            Err(_err) => error!("Error in frame"),
+        }
+
+        Timer::after_millis(250).await;
+
+        i += 1;
+        if i > 3 {
+            break;
+        }
+    }
+
+    let (mut tx, mut rx) = can.split();
+    // With split
+    loop {
+        let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
+        info!("Writing frame");
+        _ = tx.write(&frame).await;
+
+        match rx.read().await {
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {:x} {:x} {:x} {:x} --- NEW {}",
+                    rx_frame.data()[0],
+                    rx_frame.data()[1],
+                    rx_frame.data()[2],
+                    rx_frame.data()[3],
+                    delta,
+                )
+            }
             Err(_err) => error!("Error in frame"),
         }
 
diff --git a/examples/stm32h7/src/bin/can.rs b/examples/stm32h7/src/bin/can.rs
index 2906d1576..4b29a0d21 100644
--- a/examples/stm32h7/src/bin/can.rs
+++ b/examples/stm32h7/src/bin/can.rs
@@ -16,54 +16,77 @@ bind_interrupts!(struct Irqs {
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = Config::default();
-
-    // configure FDCAN to use PLL1_Q at 64 MHz
-    config.rcc.pll1 = Some(rcc::Pll {
-        source: rcc::PllSource::HSI,
-        prediv: rcc::PllPreDiv::DIV4,
-        mul: rcc::PllMul::MUL8,
-        divp: None,
-        divq: Some(rcc::PllDiv::DIV2),
-        divr: None,
+    config.rcc.hse = Some(rcc::Hse {
+        freq: embassy_stm32::time::Hertz(25_000_000),
+        mode: rcc::HseMode::Oscillator,
     });
-    config.rcc.fdcan_clock_source = rcc::FdCanClockSource::PLL1_Q;
+    config.rcc.fdcan_clock_source = rcc::FdCanClockSource::HSE;
 
     let peripherals = embassy_stm32::init(config);
 
+    //let mut can = can::Fdcan::new(peripherals.FDCAN1, peripherals.PB8, peripherals.PB9, Irqs);
     let mut can = can::Fdcan::new(peripherals.FDCAN1, peripherals.PA11, peripherals.PA12, Irqs);
 
-    can.can.apply_config(
-        can::config::FdCanConfig::default().set_nominal_bit_timing(can::config::NominalBitTiming {
-            sync_jump_width: 1.try_into().unwrap(),
-            prescaler: 8.try_into().unwrap(),
-            seg1: 13.try_into().unwrap(),
-            seg2: 2.try_into().unwrap(),
-        }),
-    );
+    // 250k bps
+    can.set_bitrate(250_000);
 
-    info!("Configured");
+    //let mut can = can.into_internal_loopback_mode();
+    let mut can = can.into_normal_mode();
 
-    let mut can = can.into_external_loopback_mode();
-    //let mut can = can.into_normal_mode();
+    info!("CAN Configured");
 
     let mut i = 0;
+    let mut last_read_ts = embassy_time::Instant::now();
+
     loop {
-        let 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 frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
         info!("Writing frame");
         _ = can.write(&frame).await;
 
         match can.read().await {
-            Ok(rx_frame) => info!("Rx: {}", rx_frame.data()[0]),
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {:x} {:x} {:x} {:x} --- NEW {}",
+                    rx_frame.data()[0],
+                    rx_frame.data()[1],
+                    rx_frame.data()[2],
+                    rx_frame.data()[3],
+                    delta,
+                )
+            }
+            Err(_err) => error!("Error in frame"),
+        }
+
+        Timer::after_millis(250).await;
+
+        i += 1;
+        if i > 3 {
+            break;
+        }
+    }
+
+    let (mut tx, mut rx) = can.split();
+    // With split
+    loop {
+        let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
+        info!("Writing frame");
+        _ = tx.write(&frame).await;
+
+        match rx.read().await {
+            Ok((rx_frame, ts)) => {
+                let delta = (ts - last_read_ts).as_millis();
+                last_read_ts = ts;
+                info!(
+                    "Rx: {:x} {:x} {:x} {:x} --- NEW {}",
+                    rx_frame.data()[0],
+                    rx_frame.data()[1],
+                    rx_frame.data()[2],
+                    rx_frame.data()[3],
+                    delta,
+                )
+            }
             Err(_err) => error!("Error in frame"),
         }