Add tests

Author: usbalbin

.cargo/config.toml

@@ -1,10 +1,5 @@
 [target.thumbv8m.main-none-eabihf]
 runner = 'probe-rs run --connect-under-reset'
-rustflags = [
-  # LLD (shipped with the Rust toolchain) is used as the default linker
-  "-C", "link-arg=-Tlink.x",
-  "-C", "link-arg=-Tdefmt.x",
-]
 
 [build]
 target = "thumbv8m.main-none-eabihf" # Cortex-M33F (with FPU)

Cargo.toml

@@ -79,6 +79,7 @@ cortex-m-semihosting = "0.5.0"
 panic-itm = { version = "~0.4.1" }
 panic-probe = "0.3.2"
 panic-semihosting = "0.6"
+embedded-test = "0.6.1"
 
 [profile.release]
 codegen-units = 1 # better optimizations
@@ -92,3 +93,11 @@ name = "blinky"
 [[example]]
 name = "i2c"
 required-features = ["stm32h503"]
+
+[[test]]
+name = "nucleo-h533"
+harness = false
+required-features = ["stm32h533", "defmt"]
+
+[lib]
+test = false

build.rs

@@ -0,0 +1,14 @@
+use std::env;
+
+fn main() {
+    // stm32 specific
+    println!("cargo:rustc-link-arg=-Tlink.x");
+
+    // add linker script for embedded-test!!
+    println!("cargo::rustc-link-arg-tests=-Tembedded-test.x");
+
+    // Check if the `defmt` feature is enabled, and if so link its linker script
+    if env::var("CARGO_FEATURE_DEFMT").is_ok() {
+        println!("cargo:rustc-link-arg=-Tdefmt.x");
+    }
+}

examples/utilities/logger.rs

@@ -13,6 +13,7 @@ cfg_if::cfg_if! {
 
 cfg_if::cfg_if! {
     if #[cfg(any(feature = "log-itm"))] {
+        #[cfg(not(test))]
         use panic_itm as _;
 
         use lazy_static::lazy_static;
@@ -55,6 +56,7 @@ cfg_if::cfg_if! {
         pub fn init() {}
     }
     else if #[cfg(any(feature = "log-rtt"))] {
+        #[cfg(not(test))]
         use panic_rtt_target as _;
 
         use log::{Level, Metadata, Record, LevelFilter};
@@ -87,6 +89,7 @@ cfg_if::cfg_if! {
         }
     }
     else if #[cfg(any(feature = "log-semihost"))] {
+        #[cfg(not(test))]
         use panic_semihosting as _;
 
         use lazy_static::lazy_static;
@@ -110,6 +113,7 @@ cfg_if::cfg_if! {
         }
     }
     else {
+        #[cfg(not(test))]
         use panic_halt as _;
         pub fn init() {}
     }

tests/common/mod.rs

@@ -0,0 +1,67 @@
+use fugit::{ExtU32, MicrosDurationU32};
+use stm32h5xx_hal::stm32;
+
+#[non_exhaustive]
+pub struct Timer<const CYCLES_PER_US: u32>;
+
+impl<const CYCLES_PER_US: u32> Timer<CYCLES_PER_US> {
+    #[allow(dead_code)]
+    pub fn enable_timer(cp: &mut stm32::CorePeripherals) -> Self {
+        cp.DCB.enable_trace();
+        cp.DWT.enable_cycle_counter();
+
+        Timer
+    }
+
+    /// Returns duration since timer start
+    pub fn now(&self) -> MicrosDurationU32 {
+        (stm32::DWT::cycle_count() / CYCLES_PER_US).micros()
+    }
+}
+
+#[allow(dead_code)]
+pub fn is_pax_low(pin: u8) -> bool {
+    let gpioa = unsafe { &*stm32::GPIOA::PTR };
+    gpioa.idr().read().id(pin).is_low()
+}
+
+#[allow(dead_code)]
+#[derive(Debug, defmt::Format)]
+pub struct ErrorTimedOut;
+
+#[allow(dead_code)]
+pub fn await_lo<const CYCLES_PER_US: u32>(
+    timer: &Timer<CYCLES_PER_US>,
+    pin: u8,
+    timeout: MicrosDurationU32,
+) -> Result<MicrosDurationU32, ErrorTimedOut> {
+    await_p(timer, || is_pax_low(pin), timeout)
+}
+
+#[allow(dead_code)]
+pub fn await_hi<const CYCLES_PER_US: u32>(
+    timer: &Timer<CYCLES_PER_US>,
+    pin: u8,
+    timeout: MicrosDurationU32,
+) -> Result<MicrosDurationU32, ErrorTimedOut> {
+    await_p(timer, || !is_pax_low(pin), timeout)
+}
+
+#[allow(dead_code)]
+pub fn await_p<const CYCLES_PER_US: u32>(
+    timer: &Timer<CYCLES_PER_US>,
+    mut p: impl FnMut() -> bool,
+    timeout: MicrosDurationU32,
+) -> Result<MicrosDurationU32, ErrorTimedOut> {
+    let before = timer.now();
+
+    loop {
+        let passed_time = timer.now() - before;
+        if p() {
+            return Ok(passed_time);
+        }
+        if passed_time > timeout {
+            return Err(ErrorTimedOut);
+        }
+    }
+}

tests/nucleo-h533.rs

@@ -0,0 +1,80 @@
+#![no_std]
+#![no_main]
+
+#[path = "../examples/utilities/mod.rs"]
+mod utils;
+
+mod common;
+
+use fugit::HertzU32;
+use hal::stm32;
+use stm32h5xx_hal::{self as hal, gpio};
+
+pub const F_SYS: HertzU32 = HertzU32::MHz(16);
+pub const CYCLES_PER_US: u32 = F_SYS.raw() / 1_000_000;
+
+use crate::common::is_pax_low;
+use embedded_hal::delay::DelayNs;
+use fugit::RateExtU32;
+use stm32h5xx_hal::{
+    delay::Delay, gpio::GpioExt, pwr::PwrExt, rcc::RccExt, stm32::GPIOA,
+};
+
+#[embedded_test::tests]
+mod tests {
+    #[test]
+    fn gpio_push_pull() {
+        use super::*;
+
+        let (gpioa, mut delay) = init();
+
+        let _pa1_important_dont_use_as_output = gpioa.pa1.into_floating_input();
+        let mut pin = gpioa.pa8.into_push_pull_output();
+        let pin_num = 8; // PA8
+
+        pin.set_high();
+        delay.delay_ms(1); // Give the pin plenty of time to go high
+        assert!(!is_pax_low(pin_num));
+
+        pin.set_low();
+        delay.delay_ms(1); // Give the pin plenty of time to go low
+        assert!(is_pax_low(pin_num));
+    }
+
+    #[test]
+    fn gpio_open_drain() {
+        use super::*;
+
+        let (gpioa, mut delay) = init();
+        let _pa1_important_dont_use_as_output = gpioa.pa1.into_floating_input();
+        let mut pin = gpioa.pa8.into_open_drain_output().internal_pull_up(on);
+        let pin_num = 8; // PA8
+
+        pin.set_high();
+        delay.delay_ms(1); // Give the pin plenty of time to go high
+        assert!(pin.is_high());
+        assert!(!is_pax_low(pin_num));
+
+        pin.set_low();
+        delay.delay_ms(1); // Give the pin plenty of time to go low
+        assert!(pin.is_low());
+        assert!(is_pax_low(pin_num));
+    }
+}
+
+fn init() -> (gpio::gpioa::Parts, Delay) {
+    utils::logger::init();
+    let cp = stm32::CorePeripherals::take().unwrap();
+    let dp = stm32::Peripherals::take().unwrap();
+    let pwr = dp.PWR.constrain();
+    let pwrcfg = pwr.vos0().freeze();
+
+    // Constrain and Freeze clock
+    let rcc = dp.RCC.constrain();
+    let ccdr = rcc.sys_ck(250u32.MHz()).freeze(pwrcfg, &dp.SBS);
+
+    let delay = Delay::new(cp.SYST, &ccdr.clocks);
+    let gpioa = dp.GPIOA.split(ccdr.peripheral.GPIOA);
+
+    (gpioa, delay)
+}