Merge branch 'main' of https://github.com/embassy-rs/embassy into hrtim

9 files changed, 234 insertions, 13 deletions

diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
index 398ab9d27..e2adfe0be 100644
--- a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -118,9 +118,9 @@ const WIFI_NETWORK: &str = "EmbassyTest";
 const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
 
 const TEST_DURATION: usize = 10;
-const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 150;
-const TEST_EXPECTED_UPLOAD_KBPS: usize = 150;
-const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 150;
+const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 50;
+const TEST_EXPECTED_UPLOAD_KBPS: usize = 50;
+const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 50;
 const RX_BUFFER_SIZE: usize = 4096;
 const TX_BUFFER_SIZE: usize = 4096;
 const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
diff --git a/tests/rp/src/bin/cyw43-perf.rs b/tests/rp/src/bin/cyw43-perf.rs
index bc127e2e5..fffdabc9b 100644
--- a/tests/rp/src/bin/cyw43-perf.rs
+++ b/tests/rp/src/bin/cyw43-perf.rs
@@ -48,9 +48,9 @@ async fn main(spawner: Spawner) {
     }
 
     // cyw43 firmware needs to be flashed manually:
-    //     probe-rs download 43439A0.bin     --format bin --chip RP2040 --base-address 0x101c0000
+    //     probe-rs download 43439A0.bin     --format bin --chip RP2040 --base-address 0x101b0000
     //     probe-rs download 43439A0_clm.bin --format bin --chip RP2040 --base-address 0x101f8000
-    let fw = unsafe { core::slice::from_raw_parts(0x101c0000 as *const u8, 224190) };
+    let fw = unsafe { core::slice::from_raw_parts(0x101b0000 as *const u8, 230321) };
     let clm = unsafe { core::slice::from_raw_parts(0x101f8000 as *const u8, 4752) };
 
     let pwr = Output::new(p.PIN_23, Level::Low);
diff --git a/tests/rp/src/bin/pio_irq.rs b/tests/rp/src/bin/pio_irq.rs
index 45004424a..bdea63eaa 100644
--- a/tests/rp/src/bin/pio_irq.rs
+++ b/tests/rp/src/bin/pio_irq.rs
@@ -9,7 +9,6 @@ use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::PIO0;
 use embassy_rp::pio::{Config, InterruptHandler, Pio};
-use embassy_rp::relocate::RelocatedProgram;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -35,9 +34,8 @@ async fn main(_spawner: Spawner) {
         "irq wait 1",
     );
 
-    let relocated = RelocatedProgram::new(&prg.program);
     let mut cfg = Config::default();
-    cfg.use_program(&common.load_program(&relocated), &[]);
+    cfg.use_program(&common.load_program(&prg.program), &[]);
     sm.set_config(&cfg);
     sm.set_enable(true);
 
diff --git a/tests/rp/src/bin/pio_multi_load.rs b/tests/rp/src/bin/pio_multi_load.rs
new file mode 100644
index 000000000..356f16795
--- /dev/null
+++ b/tests/rp/src/bin/pio_multi_load.rs
@@ -0,0 +1,126 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+#[path = "../common.rs"]
+mod common;
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{Config, InterruptHandler, LoadError, Pio};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let pio = p.PIO0;
+    let Pio {
+        mut common,
+        mut sm0,
+        mut sm1,
+        mut sm2,
+        irq_flags,
+        ..
+    } = Pio::new(pio, Irqs);
+
+    // load with explicit origin works
+    let prg1 = pio_proc::pio_asm!(
+        ".origin 4"
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "irq 0",
+        "nop",
+        "nop",
+    );
+    let loaded1 = common.load_program(&prg1.program);
+    assert_eq!(loaded1.origin, 4);
+    assert_eq!(loaded1.wrap.source, 13);
+    assert_eq!(loaded1.wrap.target, 4);
+
+    // load without origin chooses a free space
+    let prg2 = pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 1", "nop", "nop",);
+    let loaded2 = common.load_program(&prg2.program);
+    assert_eq!(loaded2.origin, 14);
+    assert_eq!(loaded2.wrap.source, 23);
+    assert_eq!(loaded2.wrap.target, 14);
+
+    // wrapping around the end of program space automatically works
+    let prg3 =
+        pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 2",);
+    let loaded3 = common.load_program(&prg3.program);
+    assert_eq!(loaded3.origin, 24);
+    assert_eq!(loaded3.wrap.source, 3);
+    assert_eq!(loaded3.wrap.target, 24);
+
+    // check that the programs actually work
+    {
+        let mut cfg = Config::default();
+        cfg.use_program(&loaded1, &[]);
+        sm0.set_config(&cfg);
+        sm0.set_enable(true);
+        while !irq_flags.check(0) {}
+        sm0.set_enable(false);
+    }
+    {
+        let mut cfg = Config::default();
+        cfg.use_program(&loaded2, &[]);
+        sm1.set_config(&cfg);
+        sm1.set_enable(true);
+        while !irq_flags.check(1) {}
+        sm1.set_enable(false);
+    }
+    {
+        let mut cfg = Config::default();
+        cfg.use_program(&loaded3, &[]);
+        sm2.set_config(&cfg);
+        sm2.set_enable(true);
+        while !irq_flags.check(2) {}
+        sm2.set_enable(false);
+    }
+
+    // instruction memory is full now. all loads should fail.
+    {
+        let prg = pio_proc::pio_asm!(".origin 0", "nop");
+        match common.try_load_program(&prg.program) {
+            Err(LoadError::AddressInUse(0)) => (),
+            _ => panic!("program loaded when it shouldn't"),
+        };
+
+        let prg = pio_proc::pio_asm!("nop");
+        match common.try_load_program(&prg.program) {
+            Err(LoadError::InsufficientSpace) => (),
+            _ => panic!("program loaded when it shouldn't"),
+        };
+    }
+
+    // freeing some memory should allow further loads though.
+    unsafe {
+        common.free_instr(loaded3.used_memory);
+    }
+    {
+        let prg = pio_proc::pio_asm!(".origin 0", "nop");
+        match common.try_load_program(&prg.program) {
+            Ok(_) => (),
+            _ => panic!("program didn't loaded when it shouldn"),
+        };
+
+        let prg = pio_proc::pio_asm!("nop");
+        match common.try_load_program(&prg.program) {
+            Ok(_) => (),
+            _ => panic!("program didn't loaded when it shouldn"),
+        };
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/stm32/Cargo.toml b/tests/stm32/Cargo.toml
index 3007cd1e6..17320649e 100644
--- a/tests/stm32/Cargo.toml
+++ b/tests/stm32/Cargo.toml
@@ -7,11 +7,11 @@ autobins = false
 
 [features]
 stm32f103c8 = ["embassy-stm32/stm32f103c8", "not-gpdma"]     # Blue Pill
-stm32f429zi = ["embassy-stm32/stm32f429zi", "chrono", "can", "not-gpdma"]     # Nucleo "sdmmc"
-stm32g071rb = ["embassy-stm32/stm32g071rb", "not-gpdma"]     # Nucleo
+stm32f429zi = ["embassy-stm32/stm32f429zi", "chrono", "can", "not-gpdma", "dac-adc-pin"]     # Nucleo "sdmmc"
+stm32g071rb = ["embassy-stm32/stm32g071rb", "not-gpdma", "dac-adc-pin"]     # Nucleo
 stm32c031c6 = ["embassy-stm32/stm32c031c6", "not-gpdma"]     # Nucleo
 stm32g491re = ["embassy-stm32/stm32g491re", "not-gpdma"]     # Nucleo
-stm32h755zi = ["embassy-stm32/stm32h755zi-cm7", "not-gpdma"] # Nucleo
+stm32h755zi = ["embassy-stm32/stm32h755zi-cm7", "not-gpdma", "dac-adc-pin"] # Nucleo
 stm32wb55rg = ["embassy-stm32/stm32wb55rg", "not-gpdma", "ble", "mac" ]     # Nucleo
 stm32h563zi = ["embassy-stm32/stm32h563zi"]     # Nucleo
 stm32u585ai = ["embassy-stm32/stm32u585ai"]     # IoT board
@@ -23,6 +23,7 @@ ble = ["dep:embassy-stm32-wpan", "embassy-stm32-wpan/ble"]
 mac = ["dep:embassy-stm32-wpan", "embassy-stm32-wpan/mac"]
 embassy-stm32-wpan = []
 not-gpdma = []
+dac-adc-pin = []
 
 [dependencies]
 teleprobe-meta = "1"
@@ -42,6 +43,7 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-alpha.11" }
 embedded-hal-async = { version = "=0.2.0-alpha.2" }
+micromath = "2.0.0"
 panic-probe = { version = "0.3.0", features = ["print-defmt"] }
 rand_core = { version = "0.6", default-features = false }
 rand_chacha = { version = "0.3", default-features = false }
@@ -56,6 +58,11 @@ path = "src/bin/can.rs"
 required-features = [ "can",]
 
 [[bin]]
+name = "dac"
+path = "src/bin/dac.rs"
+required-features = [ "dac-adc-pin",]
+
+[[bin]]
 name = "gpio"
 path = "src/bin/gpio.rs"
 required-features = []
diff --git a/tests/stm32/src/bin/dac.rs b/tests/stm32/src/bin/dac.rs
new file mode 100644
index 000000000..67a7d5b59
--- /dev/null
+++ b/tests/stm32/src/bin/dac.rs
@@ -0,0 +1,81 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+// required-features: dac-adc-pin
+
+#[path = "../common.rs"]
+mod common;
+use common::*;
+use defmt::assert;
+use embassy_executor::Spawner;
+use embassy_stm32::adc::Adc;
+use embassy_stm32::dac::{DacCh1, DacChannel, Value};
+use embassy_stm32::dma::NoDma;
+use embassy_time::{Delay, Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    // Initialize the board and obtain a Peripherals instance
+    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
+
+    #[cfg(feature = "stm32f429zi")]
+    let dac_peripheral = p.DAC;
+
+    #[cfg(any(feature = "stm32h755zi", feature = "stm32g071rb"))]
+    let dac_peripheral = p.DAC1;
+
+    let mut dac: DacCh1<'_, _, NoDma> = DacCh1::new(dac_peripheral, NoDma, p.PA4);
+    unwrap!(dac.set_trigger_enable(false));
+
+    let mut adc = Adc::new(p.ADC1, &mut Delay);
+
+    #[cfg(feature = "stm32h755zi")]
+    let normalization_factor = 256;
+    #[cfg(any(feature = "stm32f429zi", feature = "stm32g071rb"))]
+    let normalization_factor: i32 = 16;
+
+    unwrap!(dac.set(Value::Bit8(0)));
+    // Now wait a little to obtain a stable value
+    Timer::after(Duration::from_millis(30)).await;
+    let offset = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4);
+
+    for v in 0..=255 {
+        // First set the DAC output value
+        let dac_output_val = to_sine_wave(v);
+        unwrap!(dac.set(Value::Bit8(dac_output_val)));
+
+        // Now wait a little to obtain a stable value
+        Timer::after(Duration::from_millis(30)).await;
+
+        // Need to steal the peripherals here because PA4 is obviously in use already
+        let measured = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4);
+        // Calibrate and normalize the measurement to get close to the dac_output_val
+        let measured_normalized = ((measured as i32 - offset as i32) / normalization_factor) as i16;
+
+        info!("value / measured: {} / {}", dac_output_val, measured_normalized);
+
+        // The deviations are quite enormous but that does not matter since this is only a quick test
+        assert!((dac_output_val as i16 - measured_normalized).abs() < 15);
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+use core::f32::consts::PI;
+
+use micromath::F32Ext;
+
+fn to_sine_wave(v: u8) -> u8 {
+    if v >= 128 {
+        // top half
+        let r = PI * ((v - 128) as f32 / 128.0);
+        (r.sin() * 128.0 + 127.0) as u8
+    } else {
+        // bottom half
+        let r = PI + PI * (v as f32 / 128.0);
+        (r.sin() * 128.0 + 127.0) as u8
+    }
+}
diff --git a/tests/stm32/src/bin/wpan_ble.rs b/tests/stm32/src/bin/wpan_ble.rs
index 3ad8aca4e..452da77a4 100644
--- a/tests/stm32/src/bin/wpan_ble.rs
+++ b/tests/stm32/src/bin/wpan_ble.rs
@@ -12,6 +12,7 @@ use common::*;
 use embassy_executor::Spawner;
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
+use embassy_stm32::rcc::WPAN_DEFAULT;
 use embassy_stm32_wpan::hci::host::uart::UartHci;
 use embassy_stm32_wpan::hci::host::{AdvertisingFilterPolicy, EncryptionKey, HostHci, OwnAddressType};
 use embassy_stm32_wpan::hci::types::AdvertisingType;
@@ -40,7 +41,10 @@ async fn run_mm_queue(memory_manager: mm::MemoryManager) {
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let mut config = config();
+    config.rcc = WPAN_DEFAULT;
+
+    let p = embassy_stm32::init(config);
     info!("Hello World!");
 
     let config = Config::default();
diff --git a/tests/stm32/src/bin/wpan_mac.rs b/tests/stm32/src/bin/wpan_mac.rs
index b04a19ee9..7eab2fd38 100644
--- a/tests/stm32/src/bin/wpan_mac.rs
+++ b/tests/stm32/src/bin/wpan_mac.rs
@@ -10,6 +10,7 @@ use common::*;
 use embassy_executor::Spawner;
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
+use embassy_stm32::rcc::WPAN_DEFAULT;
 use embassy_stm32_wpan::mac::commands::{AssociateRequest, GetRequest, ResetRequest, SetRequest};
 use embassy_stm32_wpan::mac::event::MacEvent;
 use embassy_stm32_wpan::mac::typedefs::{
@@ -31,7 +32,10 @@ async fn run_mm_queue(memory_manager: mm::MemoryManager) {
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let mut config = config();
+    config.rcc = WPAN_DEFAULT;
+
+    let p = embassy_stm32::init(config);
     info!("Hello World!");
 
     let config = Config::default();
diff --git a/tests/stm32/src/common.rs b/tests/stm32/src/common.rs
index 3d2a9b8ef..ca5cb43ac 100644
--- a/tests/stm32/src/common.rs
+++ b/tests/stm32/src/common.rs
@@ -33,6 +33,7 @@ pub fn config() -> Config {
     {
         config.rcc.sys_ck = Some(Hertz(400_000_000));
         config.rcc.pll1.q_ck = Some(Hertz(100_000_000));
+        config.rcc.adc_clock_source = embassy_stm32::rcc::AdcClockSource::PerCk;
     }
 
     #[cfg(feature = "stm32u585ai")]