NaxdyOrg/embassy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

time: Update examples, tests, and other code to use new Timer::after_x convenience methods

Browse source
This commit is contained in:
Adam Greig 2023-10-15 00:57:25 +01:00
parent 7559f9e583
commit 0621e957a0
No known key found for this signature in database
GPG key ID: 8B3FE5477B1DD9A0
174 changed files with 496 additions and 501 deletions

4
tests/nrf/src/bin/buffered_uart_spam.rs
View file

@ -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;

4
tests/nrf/src/bin/timer.rs
View file

@ -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);

2
tests/perf-client/src/lib.rs
View file

@ -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!");

4
tests/rp/src/bin/bootsel.rs
View file

@ -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);

4
tests/rp/src/bin/flash.rs
View file

@ -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);

4
tests/rp/src/bin/float.rs
View file

@ -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();

12
tests/rp/src/bin/gpio_async.rs
View file

@ -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 {

44
tests/rp/src/bin/pwm.rs
View file

@ -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);
}

10
tests/rp/src/bin/uart.rs
View file

@ -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]

10
tests/rp/src/bin/uart_buffered.rs
View file

@ -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]

12
tests/rp/src/bin/uart_dma.rs
View file

@ -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]));
}

6
tests/stm32/src/bin/dac.rs
View file

@ -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);

4
tests/stm32/src/bin/rtc.rs
View file

@ -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();

6
tests/stm32/src/bin/stop.rs
View file

@ -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");

4
tests/stm32/src/bin/timer.rs
View file

@ -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);

8
tests/stm32/src/bin/usart_rx_ringbuffered.rs
View file

@ -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;