16 files changed, 69 insertions, 69 deletions

diff --git a/tests/nrf/src/bin/buffered_uart_spam.rs b/tests/nrf/src/bin/buffered_uart_spam.rs
index 8abeae6d4..65b9d76d1 100644
--- a/tests/nrf/src/bin/buffered_uart_spam.rs
+++ b/tests/nrf/src/bin/buffered_uart_spam.rs
@@ -13,7 +13,7 @@ use embassy_nrf::gpio::{Level, Output, OutputDrive};
 use embassy_nrf::ppi::{Event, Ppi, Task};
 use embassy_nrf::uarte::Uarte;
 use embassy_nrf::{bind_interrupts, pac, peripherals, uarte};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -50,7 +50,7 @@ async fn main(_spawner: Spawner) {
     info!("uarte initialized!");
 
     // uarte needs some quiet time to start rxing properly.
-    Timer::after(Duration::from_millis(10)).await;
+    Timer::after_millis(10).await;
 
     // Tx spam in a loop.
     const NSPAM: usize = 17;
diff --git a/tests/nrf/src/bin/timer.rs b/tests/nrf/src/bin/timer.rs
index c00f35fd1..5723acb01 100644
--- a/tests/nrf/src/bin/timer.rs
+++ b/tests/nrf/src/bin/timer.rs
@@ -5,7 +5,7 @@ teleprobe_meta::target!(b"nrf52840-dk");
 
 use defmt::{assert, info};
 use embassy_executor::Spawner;
-use embassy_time::{Duration, Instant, Timer};
+use embassy_time::{Instant, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -14,7 +14,7 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let start = Instant::now();
-    Timer::after(Duration::from_millis(100)).await;
+    Timer::after_millis(100).await;
     let end = Instant::now();
     let ms = (end - start).as_millis();
     info!("slept for {} ms", ms);
diff --git a/tests/perf-client/src/lib.rs b/tests/perf-client/src/lib.rs
index d709c7bd0..54762379a 100644
--- a/tests/perf-client/src/lib.rs
+++ b/tests/perf-client/src/lib.rs
@@ -16,7 +16,7 @@ pub struct Expected {
 pub async fn run<D: Driver>(stack: &Stack<D>, expected: Expected) {
     info!("Waiting for DHCP up...");
     while stack.config_v4().is_none() {
-        Timer::after(Duration::from_millis(100)).await;
+        Timer::after_millis(100).await;
     }
     info!("IP addressing up!");
 
diff --git a/tests/rp/src/bin/bootsel.rs b/tests/rp/src/bin/bootsel.rs
index df1ed8d2e..4678775eb 100644
--- a/tests/rp/src/bin/bootsel.rs
+++ b/tests/rp/src/bin/bootsel.rs
@@ -5,7 +5,7 @@ teleprobe_meta::target!(b"rpi-pico");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -17,7 +17,7 @@ async fn main(_spawner: Spawner) {
     // defmt RTT header. Reading that header might touch flash memory, which
     // interferes with flash write operations.
     // https://github.com/knurling-rs/defmt/pull/683
-    Timer::after(Duration::from_millis(10)).await;
+    Timer::after_millis(10).await;
 
     assert_eq!(p.BOOTSEL.is_pressed(), false);
 
diff --git a/tests/rp/src/bin/flash.rs b/tests/rp/src/bin/flash.rs
index 75be2bf06..2d85135de 100644
--- a/tests/rp/src/bin/flash.rs
+++ b/tests/rp/src/bin/flash.rs
@@ -6,7 +6,7 @@ teleprobe_meta::target!(b"rpi-pico");
 use defmt::*;
 use embassy_executor::Spawner;
 use embassy_rp::flash::{Async, ERASE_SIZE, FLASH_BASE};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 const ADDR_OFFSET: u32 = 0x8000;
@@ -20,7 +20,7 @@ async fn main(_spawner: Spawner) {
     // defmt RTT header. Reading that header might touch flash memory, which
     // interferes with flash write operations.
     // https://github.com/knurling-rs/defmt/pull/683
-    Timer::after(Duration::from_millis(10)).await;
+    Timer::after_millis(10).await;
 
     let mut flash = embassy_rp::flash::Flash::<_, Async, { 2 * 1024 * 1024 }>::new(p.FLASH, p.DMA_CH0);
 
diff --git a/tests/rp/src/bin/float.rs b/tests/rp/src/bin/float.rs
index 2874aa910..1e89c10f8 100644
--- a/tests/rp/src/bin/float.rs
+++ b/tests/rp/src/bin/float.rs
@@ -6,7 +6,7 @@ teleprobe_meta::target!(b"rpi-pico");
 use defmt::*;
 use embassy_executor::Spawner;
 use embassy_rp::pac;
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -40,7 +40,7 @@ async fn main(_spawner: Spawner) {
             rad_d + PI_D,
             rad_d % PI_D
         );
-        Timer::after(Duration::from_millis(10)).await;
+        Timer::after_millis(10).await;
     }
 
     let rom_accesses = pac::BUSCTRL.perfctr(0).read().perfctr();
diff --git a/tests/rp/src/bin/gpio_async.rs b/tests/rp/src/bin/gpio_async.rs
index 60c65b7a0..26582f74b 100644
--- a/tests/rp/src/bin/gpio_async.rs
+++ b/tests/rp/src/bin/gpio_async.rs
@@ -27,7 +27,7 @@ async fn main(_spawner: Spawner) {
 
         let set_high_future = async {
             // Allow time for wait_for_high_future to await wait_for_high().
-            Timer::after(Duration::from_millis(10)).await;
+            Timer::after_millis(10).await;
             output.set_high();
         };
         let wait_for_high_future = async {
@@ -47,7 +47,7 @@ async fn main(_spawner: Spawner) {
         assert!(input.is_high(), "input was expected to be high");
 
         let set_low_future = async {
-            Timer::after(Duration::from_millis(10)).await;
+            Timer::after_millis(10).await;
             output.set_low();
         };
         let wait_for_low_future = async {
@@ -67,7 +67,7 @@ async fn main(_spawner: Spawner) {
         assert!(input.is_low(), "input was expected to be low");
 
         let set_high_future = async {
-            Timer::after(Duration::from_millis(10)).await;
+            Timer::after_millis(10).await;
             output.set_high();
         };
         let wait_for_rising_edge_future = async {
@@ -87,7 +87,7 @@ async fn main(_spawner: Spawner) {
         assert!(input.is_high(), "input was expected to be high");
 
         let set_low_future = async {
-            Timer::after(Duration::from_millis(10)).await;
+            Timer::after_millis(10).await;
             output.set_low();
         };
         let wait_for_falling_edge_future = async {
@@ -107,7 +107,7 @@ async fn main(_spawner: Spawner) {
         assert!(input.is_high(), "input was expected to be high");
 
         let set_low_future = async {
-            Timer::after(Duration::from_millis(10)).await;
+            Timer::after_millis(10).await;
             output.set_low();
         };
         let wait_for_any_edge_future = async {
@@ -127,7 +127,7 @@ async fn main(_spawner: Spawner) {
         assert!(input.is_low(), "input was expected to be low");
 
         let set_high_future = async {
-            Timer::after(Duration::from_millis(10)).await;
+            Timer::after_millis(10).await;
             output.set_high();
         };
         let wait_for_any_edge_future = async {
diff --git a/tests/rp/src/bin/pwm.rs b/tests/rp/src/bin/pwm.rs
index 8c02b8441..8c9db1158 100644
--- a/tests/rp/src/bin/pwm.rs
+++ b/tests/rp/src/bin/pwm.rs
@@ -7,7 +7,7 @@ use defmt::{assert, assert_eq, assert_ne, *};
 use embassy_executor::Spawner;
 use embassy_rp::gpio::{Input, Level, Output, Pull};
 use embassy_rp::pwm::{Config, InputMode, Pwm};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -48,13 +48,13 @@ async fn main(_spawner: Spawner) {
         {
             let pin1 = Input::new(&mut p9, Pull::None);
             let _pwm = Pwm::new_output_a(&mut p.PWM_CH3, &mut p6, cfg.clone());
-            Timer::after(Duration::from_millis(1)).await;
+            Timer::after_millis(1).await;
             assert_eq!(pin1.is_low(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_eq!(pin1.is_high(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_eq!(pin1.is_low(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_eq!(pin1.is_high(), invert_a);
         }
 
@@ -62,13 +62,13 @@ async fn main(_spawner: Spawner) {
         {
             let pin2 = Input::new(&mut p11, Pull::None);
             let _pwm = Pwm::new_output_b(&mut p.PWM_CH3, &mut p7, cfg.clone());
-            Timer::after(Duration::from_millis(1)).await;
+            Timer::after_millis(1).await;
             assert_ne!(pin2.is_low(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_ne!(pin2.is_high(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_ne!(pin2.is_low(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_ne!(pin2.is_high(), invert_a);
         }
 
@@ -77,16 +77,16 @@ async fn main(_spawner: Spawner) {
             let pin1 = Input::new(&mut p9, Pull::None);
             let pin2 = Input::new(&mut p11, Pull::None);
             let _pwm = Pwm::new_output_ab(&mut p.PWM_CH3, &mut p6, &mut p7, cfg.clone());
-            Timer::after(Duration::from_millis(1)).await;
+            Timer::after_millis(1).await;
             assert_eq!(pin1.is_low(), invert_a);
             assert_ne!(pin2.is_low(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_eq!(pin1.is_high(), invert_a);
             assert_ne!(pin2.is_high(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_eq!(pin1.is_low(), invert_a);
             assert_ne!(pin2.is_low(), invert_a);
-            Timer::after(Duration::from_millis(5)).await;
+            Timer::after_millis(5).await;
             assert_eq!(pin1.is_high(), invert_a);
             assert_ne!(pin2.is_high(), invert_a);
         }
@@ -97,14 +97,14 @@ async fn main(_spawner: Spawner) {
         let mut pin2 = Output::new(&mut p11, Level::Low);
         let pwm = Pwm::new_input(&mut p.PWM_CH3, &mut p7, InputMode::Level, cfg.clone());
         assert_eq!(pwm.counter(), 0);
-        Timer::after(Duration::from_millis(5)).await;
+        Timer::after_millis(5).await;
         assert_eq!(pwm.counter(), 0);
         pin2.set_high();
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         pin2.set_low();
         let ctr = pwm.counter();
         assert!(ctr >= 1000);
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         assert_eq!(pwm.counter(), ctr);
     }
 
@@ -113,13 +113,13 @@ async fn main(_spawner: Spawner) {
         let mut pin2 = Output::new(&mut p11, Level::Low);
         let pwm = Pwm::new_input(&mut p.PWM_CH3, &mut p7, InputMode::RisingEdge, cfg.clone());
         assert_eq!(pwm.counter(), 0);
-        Timer::after(Duration::from_millis(5)).await;
+        Timer::after_millis(5).await;
         assert_eq!(pwm.counter(), 0);
         pin2.set_high();
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         pin2.set_low();
         assert_eq!(pwm.counter(), 1);
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         assert_eq!(pwm.counter(), 1);
     }
 
@@ -128,13 +128,13 @@ async fn main(_spawner: Spawner) {
         let mut pin2 = Output::new(&mut p11, Level::High);
         let pwm = Pwm::new_input(&mut p.PWM_CH3, &mut p7, InputMode::FallingEdge, cfg.clone());
         assert_eq!(pwm.counter(), 0);
-        Timer::after(Duration::from_millis(5)).await;
+        Timer::after_millis(5).await;
         assert_eq!(pwm.counter(), 0);
         pin2.set_low();
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         pin2.set_high();
         assert_eq!(pwm.counter(), 1);
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         assert_eq!(pwm.counter(), 1);
     }
 
diff --git a/tests/rp/src/bin/uart.rs b/tests/rp/src/bin/uart.rs
index 00f3e1949..8d351a3a7 100644
--- a/tests/rp/src/bin/uart.rs
+++ b/tests/rp/src/bin/uart.rs
@@ -7,7 +7,7 @@ use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::uart::{Blocking, Config, Error, Instance, Parity, Uart, UartRx};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 fn read<const N: usize>(uart: &mut Uart<'_, impl Instance, Blocking>) -> Result<[u8; N], Error> {
@@ -24,14 +24,14 @@ fn read1<const N: usize>(uart: &mut UartRx<'_, impl Instance, Blocking>) -> Resu
 
 async fn send(pin: &mut Output<'_, impl embassy_rp::gpio::Pin>, v: u8, parity: Option<bool>) {
     pin.set_low();
-    Timer::after(Duration::from_millis(1)).await;
+    Timer::after_millis(1).await;
     for i in 0..8 {
         if v & (1 << i) == 0 {
             pin.set_low();
         } else {
             pin.set_high();
         }
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
     }
     if let Some(b) = parity {
         if b {
@@ -39,10 +39,10 @@ async fn send(pin: &mut Output<'_, impl embassy_rp::gpio::Pin>, v: u8, parity: O
         } else {
             pin.set_low();
         }
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
     }
     pin.set_high();
-    Timer::after(Duration::from_millis(1)).await;
+    Timer::after_millis(1).await;
 }
 
 #[embassy_executor::main]
diff --git a/tests/rp/src/bin/uart_buffered.rs b/tests/rp/src/bin/uart_buffered.rs
index 6ab7de29e..6a9c910ff 100644
--- a/tests/rp/src/bin/uart_buffered.rs
+++ b/tests/rp/src/bin/uart_buffered.rs
@@ -9,7 +9,7 @@ use embassy_rp::bind_interrupts;
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::UART0;
 use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart, BufferedUartRx, Config, Error, Instance, Parity};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use embedded_io_async::{Read, ReadExactError, Write};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -39,14 +39,14 @@ async fn read1<const N: usize>(uart: &mut BufferedUartRx<'_, impl Instance>) ->
 
 async fn send(pin: &mut Output<'_, impl embassy_rp::gpio::Pin>, v: u8, parity: Option<bool>) {
     pin.set_low();
-    Timer::after(Duration::from_millis(1)).await;
+    Timer::after_millis(1).await;
     for i in 0..8 {
         if v & (1 << i) == 0 {
             pin.set_low();
         } else {
             pin.set_high();
         }
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
     }
     if let Some(b) = parity {
         if b {
@@ -54,10 +54,10 @@ async fn send(pin: &mut Output<'_, impl embassy_rp::gpio::Pin>, v: u8, parity: O
         } else {
             pin.set_low();
         }
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
     }
     pin.set_high();
-    Timer::after(Duration::from_millis(1)).await;
+    Timer::after_millis(1).await;
 }
 
 #[embassy_executor::main]
diff --git a/tests/rp/src/bin/uart_dma.rs b/tests/rp/src/bin/uart_dma.rs
index cd4af1ef2..e79fcde60 100644
--- a/tests/rp/src/bin/uart_dma.rs
+++ b/tests/rp/src/bin/uart_dma.rs
@@ -9,7 +9,7 @@ use embassy_rp::bind_interrupts;
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::UART0;
 use embassy_rp::uart::{Async, Config, Error, Instance, InterruptHandler, Parity, Uart, UartRx};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -30,14 +30,14 @@ async fn read1<const N: usize>(uart: &mut UartRx<'_, impl Instance, Async>) -> R
 
 async fn send(pin: &mut Output<'_, impl embassy_rp::gpio::Pin>, v: u8, parity: Option<bool>) {
     pin.set_low();
-    Timer::after(Duration::from_millis(1)).await;
+    Timer::after_millis(1).await;
     for i in 0..8 {
         if v & (1 << i) == 0 {
             pin.set_low();
         } else {
             pin.set_high();
         }
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
     }
     if let Some(b) = parity {
         if b {
@@ -45,10 +45,10 @@ async fn send(pin: &mut Output<'_, impl embassy_rp::gpio::Pin>, v: u8, parity: O
         } else {
             pin.set_low();
         }
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
     }
     pin.set_high();
-    Timer::after(Duration::from_millis(1)).await;
+    Timer::after_millis(1).await;
 }
 
 #[embassy_executor::main]
@@ -105,7 +105,7 @@ async fn main(_spawner: Spawner) {
         // new data is accepted, latest overrunning byte first
         assert_eq!(read(&mut uart).await, Ok([3]));
         uart.blocking_write(&[8, 9]).unwrap();
-        Timer::after(Duration::from_millis(1)).await;
+        Timer::after_millis(1).await;
         assert_eq!(read(&mut uart).await, Ok([8, 9]));
     }
 
diff --git a/tests/stm32/src/bin/dac.rs b/tests/stm32/src/bin/dac.rs
index fb7a84b1b..10e3c3e81 100644
--- a/tests/stm32/src/bin/dac.rs
+++ b/tests/stm32/src/bin/dac.rs
@@ -12,7 +12,7 @@ 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 embassy_time::{Delay, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -38,7 +38,7 @@ async fn main(_spawner: Spawner) {
 
     unwrap!(dac.set(Value::Bit8(0)));
     // Now wait a little to obtain a stable value
-    Timer::after(Duration::from_millis(30)).await;
+    Timer::after_millis(30).await;
     let offset = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4);
 
     for v in 0..=255 {
@@ -47,7 +47,7 @@ async fn main(_spawner: Spawner) {
         unwrap!(dac.set(Value::Bit8(dac_output_val)));
 
         // Now wait a little to obtain a stable value
-        Timer::after(Duration::from_millis(30)).await;
+        Timer::after_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);
diff --git a/tests/stm32/src/bin/rtc.rs b/tests/stm32/src/bin/rtc.rs
index 46fdbfaeb..64f1122a6 100644
--- a/tests/stm32/src/bin/rtc.rs
+++ b/tests/stm32/src/bin/rtc.rs
@@ -12,7 +12,7 @@ use defmt::assert;
 use embassy_executor::Spawner;
 use embassy_stm32::rcc::LsConfig;
 use embassy_stm32::rtc::{Rtc, RtcConfig};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
@@ -32,7 +32,7 @@ async fn main(_spawner: Spawner) {
     rtc.set_datetime(now.into()).expect("datetime not set");
 
     info!("Waiting 5 seconds");
-    Timer::after(Duration::from_millis(5000)).await;
+    Timer::after_millis(5000).await;
 
     let then: NaiveDateTime = rtc.now().unwrap().into();
     let seconds = (then - now).num_seconds();
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
index 929869bc9..f38924c90 100644
--- a/tests/stm32/src/bin/stop.rs
+++ b/tests/stm32/src/bin/stop.rs
@@ -14,7 +14,7 @@ use embassy_stm32::low_power::{stop_with_rtc, Executor};
 use embassy_stm32::rcc::LsConfig;
 use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_stm32::Config;
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use static_cell::make_static;
 
 #[entry]
@@ -28,7 +28,7 @@ fn main() -> ! {
 async fn task_1() {
     for _ in 0..9 {
         info!("task 1: waiting for 500ms...");
-        Timer::after(Duration::from_millis(500)).await;
+        Timer::after_millis(500).await;
     }
 }
 
@@ -36,7 +36,7 @@ async fn task_1() {
 async fn task_2() {
     for _ in 0..5 {
         info!("task 2: waiting for 1000ms...");
-        Timer::after(Duration::from_millis(1000)).await;
+        Timer::after_millis(1000).await;
     }
 
     info!("Test OK");
diff --git a/tests/stm32/src/bin/timer.rs b/tests/stm32/src/bin/timer.rs
index f8b453cda..4efeb0a49 100644
--- a/tests/stm32/src/bin/timer.rs
+++ b/tests/stm32/src/bin/timer.rs
@@ -7,7 +7,7 @@ mod common;
 use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
-use embassy_time::{Duration, Instant, Timer};
+use embassy_time::{Instant, Timer};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
@@ -15,7 +15,7 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let start = Instant::now();
-    Timer::after(Duration::from_millis(100)).await;
+    Timer::after_millis(100).await;
     let end = Instant::now();
     let ms = (end - start).as_millis();
     info!("slept for {} ms", ms);
diff --git a/tests/stm32/src/bin/usart_rx_ringbuffered.rs b/tests/stm32/src/bin/usart_rx_ringbuffered.rs
index 1ee7e596d..7e15f64b6 100644
--- a/tests/stm32/src/bin/usart_rx_ringbuffered.rs
+++ b/tests/stm32/src/bin/usart_rx_ringbuffered.rs
@@ -10,7 +10,7 @@ use common::*;
 use defmt::{assert_eq, panic};
 use embassy_executor::Spawner;
 use embassy_stm32::usart::{Config, DataBits, Parity, RingBufferedUartRx, StopBits, Uart, UartTx};
-use embassy_time::{Duration, Timer};
+use embassy_time::Timer;
 use rand_chacha::ChaCha8Rng;
 use rand_core::{RngCore, SeedableRng};
 
@@ -54,7 +54,7 @@ async fn main(spawner: Spawner) {
 #[embassy_executor::task]
 async fn transmit_task(mut tx: UartTx<'static, peris::UART, peris::UART_TX_DMA>) {
     // workaround https://github.com/embassy-rs/embassy/issues/1426
-    Timer::after(Duration::from_millis(100) as _).await;
+    Timer::after_millis(100).await;
 
     let mut rng = ChaCha8Rng::seed_from_u64(1337);
 
@@ -70,7 +70,7 @@ async fn transmit_task(mut tx: UartTx<'static, peris::UART, peris::UART_TX_DMA>)
         }
 
         tx.write(&buf[..len]).await.unwrap();
-        Timer::after(Duration::from_micros((rng.next_u32() % 1000) as _)).await;
+        Timer::after_micros((rng.next_u32() % 1000) as _).await;
     }
 }
 
@@ -98,7 +98,7 @@ async fn receive_task(mut rx: RingBufferedUartRx<'static, peris::UART, peris::UA
         }
 
         if received < max_len {
-            Timer::after(Duration::from_micros((rng.next_u32() % 1000) as _)).await;
+            Timer::after_micros((rng.next_u32() % 1000) as _).await;
         }
 
         i += received;