CAN: Use the same testing code for BXCAN and FDCAN h/w.

1 files changed, 36 insertions, 159 deletions

diff --git a/tests/stm32/src/bin/fdcan.rs b/tests/stm32/src/bin/fdcan.rs
index bddfa7684..27bdd038a 100644
--- a/tests/stm32/src/bin/fdcan.rs
+++ b/tests/stm32/src/bin/fdcan.rs
@@ -6,13 +6,15 @@
 #[path = "../common.rs"]
 mod common;
 use common::*;
-use defmt::assert;
 use embassy_executor::Spawner;
 use embassy_stm32::peripherals::*;
 use embassy_stm32::{bind_interrupts, can, Config};
-use embassy_time::{Duration, Instant};
+use embassy_time::Duration;
 use {defmt_rtt as _, panic_probe as _};
 
+mod can_common;
+use can_common::*;
+
 bind_interrupts!(struct Irqs2 {
     FDCAN2_IT0 => can::IT0InterruptHandler<FDCAN2>;
     FDCAN2_IT1 => can::IT1InterruptHandler<FDCAN2>;
@@ -22,14 +24,8 @@ bind_interrupts!(struct Irqs1 {
     FDCAN1_IT1 => can::IT1InterruptHandler<FDCAN1>;
 });
 
-struct TestOptions {
-    config: Config,
-    max_latency: Duration,
-    second_fifo_working: bool,
-}
-
 #[cfg(any(feature = "stm32h755zi", feature = "stm32h753zi", feature = "stm32h563zi"))]
-fn options() -> TestOptions {
+fn options() -> (Config, TestOptions) {
     use embassy_stm32::rcc;
     info!("H75 config");
     let mut c = config();
@@ -38,15 +34,17 @@ fn options() -> TestOptions {
         mode: rcc::HseMode::Oscillator,
     });
     c.rcc.mux.fdcansel = rcc::mux::Fdcansel::HSE;
-    TestOptions {
-        config: c,
-        max_latency: Duration::from_micros(1200),
-        second_fifo_working: false,
-    }
+    (
+        c,
+        TestOptions {
+            max_latency: Duration::from_micros(1200),
+            max_buffered: 3,
+        },
+    )
 }
 
 #[cfg(any(feature = "stm32h7a3zi"))]
-fn options() -> TestOptions {
+fn options() -> (Config, TestOptions) {
     use embassy_stm32::rcc;
     info!("H7a config");
     let mut c = config();
@@ -55,29 +53,33 @@ fn options() -> TestOptions {
         mode: rcc::HseMode::Oscillator,
     });
     c.rcc.mux.fdcansel = rcc::mux::Fdcansel::HSE;
-    TestOptions {
-        config: c,
-        max_latency: Duration::from_micros(1200),
-        second_fifo_working: false,
-    }
+    (
+        c,
+        TestOptions {
+            max_latency: Duration::from_micros(1200),
+            max_buffered: 3,
+        },
+    )
 }
 
 #[cfg(any(feature = "stm32g491re", feature = "stm32g431cb"))]
-fn options() -> TestOptions {
+fn options() -> (Config, TestOptions) {
     info!("G4 config");
-    TestOptions {
-        config: config(),
-        max_latency: Duration::from_micros(500),
-        second_fifo_working: true,
-    }
+    (
+        config(),
+        TestOptions {
+            max_latency: Duration::from_micros(500),
+            max_buffered: 6,
+        },
+    )
 }
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     //let peripherals = embassy_stm32::init(config());
 
-    let options = options();
-    let peripherals = embassy_stm32::init(options.config);
+    let (config, options) = options();
+    let peripherals = embassy_stm32::init(config);
 
     let mut can = can::CanConfigurator::new(peripherals.FDCAN1, peripherals.PB8, peripherals.PB9, Irqs1);
     let mut can2 = can::CanConfigurator::new(peripherals.FDCAN2, peripherals.PB12, peripherals.PB13, Irqs2);
@@ -98,141 +100,16 @@ async fn main(_spawner: Spawner) {
     let mut can = can.into_internal_loopback_mode();
     let mut can2 = can2.into_internal_loopback_mode();
 
-    info!("CAN Configured");
+    run_can_tests(&mut can, &options).await;
+    run_can_tests(&mut can2, &options).await;
 
-    let mut i: u8 = 0;
-    loop {
-        let tx_frame = can::frame::Frame::new_standard(0x123, &[i; 1]).unwrap();
-
-        info!("Transmitting frame...");
-        let tx_ts = Instant::now();
-        can.write(&tx_frame).await;
-
-        let (frame, timestamp) = can.read().await.unwrap().parts();
-        info!("Frame received!");
-
-        // Check data.
-        assert!(i == frame.data()[0], "{} == {}", i, frame.data()[0]);
-
-        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
-        const MIN_LATENCY: Duration = Duration::from_micros(50);
-        // Was failing at 150 but we are not getting a real time stamp. I'm not
-        // sure if there are other delays
-        assert!(
-            MIN_LATENCY <= latency && latency <= options.max_latency,
-            "{} <= {} <= {}",
-            MIN_LATENCY,
-            latency,
-            options.max_latency
-        );
-
-        i += 1;
-        if i > 10 {
-            break;
-        }
-    }
-
-    let mut i: u8 = 0;
-    loop {
-        let tx_frame = can::frame::Frame::new_standard(0x123, &[i; 1]).unwrap();
-
-        info!("Transmitting frame...");
-        let tx_ts = Instant::now();
-        can2.write(&tx_frame).await;
-
-        let (frame, timestamp) = can2.read().await.unwrap().parts();
-        info!("Frame received!");
-
-        //print_regs().await;
-        // Check data.
-        assert!(i == frame.data()[0], "{} == {}", i, frame.data()[0]);
-
-        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
-        const MIN_LATENCY: Duration = Duration::from_micros(50);
-        // Was failing at 150 but we are not getting a real time stamp. I'm not
-        // sure if there are other delays
-        assert!(
-            MIN_LATENCY <= latency && latency <= options.max_latency,
-            "{} <= {} <= {}",
-            MIN_LATENCY,
-            latency,
-            options.max_latency
-        );
-
-        i += 1;
-        if i > 10 {
-            break;
-        }
-    }
-
-    let max_buffered = if options.second_fifo_working { 6 } else { 3 };
-
-    // Below here, check that we can receive from both FIFO0 and FIFO0
-    // Above we configured FIFO1 for extended ID packets. There are only 3 slots
-    // 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::frame::Frame::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::frame::Frame::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 (frame, _ts) = can.read().await.unwrap().parts();
-        match frame.id() {
-            embedded_can::Id::Extended(id) => {
-                info!("Extended received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
-            }
-            embedded_can::Id::Standard(id) => {
-                info!("Standard received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
-            }
-        }
-    }
+    info!("CAN Configured");
 
     // Test again with a split
     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::frame::Frame::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::frame::Frame::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 (frame, _ts) = rx.read().await.unwrap().parts();
-        match frame.id() {
-            embedded_can::Id::Extended(id) => {
-                info!("Extended received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
-            }
-            embedded_can::Id::Standard(id) => {
-                info!("Standard received! {:x} {} {}", id.as_raw(), frame.data()[0], i);
-            }
-        }
-    }
+    let (mut tx2, mut rx2) = can2.split();
+    run_split_can_tests(&mut tx, &mut rx, &options).await;
+    run_split_can_tests(&mut tx2, &mut rx2, &options).await;
 
     info!("Test OK");
     cortex_m::asm::bkpt();