Simplify waiter

Author: JalonWong

Cargo.toml

@@ -65,7 +65,7 @@
     rtic-monotonic = { version = "1.0", optional = true }
     rtrb = { version = "0.3", default-features = false }
     stm32f1 = { version = "0.16", optional = true }
-    waiter-trait = "0.5"
+    waiter-trait = "0.8"
 
 [profile.release]
     codegen-units = 1

examples/f103c8/src/led_task.rs

@@ -1,11 +1,11 @@
-use crate::{embedded_hal::digital::StatefulOutputPin, waiter_trait::WaiterTime};
+use crate::{embedded_hal::digital::StatefulOutputPin, waiter_trait::WaiterStatus};
 
 pub struct LedTask<P, T> {
     led: P,
     timeout: T,
 }
 
-impl<P: StatefulOutputPin, T: WaiterTime> LedTask<P, T> {
+impl<P: StatefulOutputPin, T: WaiterStatus> LedTask<P, T> {
     pub fn new(led: P, timeout: T) -> Self {
         Self { led, timeout }
     }

examples/f103c8/src/main.rs

@@ -21,7 +21,7 @@ use stm32f1_hal::{
     time::MonoTimer,
     timer::*,
     uart::{self, UartPeriphExt},
-    waiter_trait::{self, Counter, NonInterval, Waiter},
+    waiter_trait::{self, Counter, prelude::*},
 };
 
 mod led_task;
@@ -112,7 +112,7 @@ fn main() -> ! {
     let mut led = gpiob
         .pb0
         .into_open_drain_output_with_state(&mut gpiob.crl, PinState::High);
-    let mut water = sys_timer.waiter_us(1.secs(), NonInterval::new());
+    let mut water = sys_timer.waiter(1.secs());
     // let water = mono_timer.waiter(1.secs());
     let mut led_task = LedTask::new(led, water.start());
 
@@ -173,11 +173,11 @@ fn uart_interrupt_init<U: UartPeriphExt + 'static>(
     mcu: &mut Mcu,
     timer: &SystemTimer,
 ) -> UartPollTask<impl embedded_io::Write + 'static, impl embedded_io::Read + 'static> {
-    let (rx, mut rx_it) = rx.into_interrupt(64, timer.waiter_us(100.micros(), NonInterval::new()));
+    let (rx, mut rx_it) = rx.into_interrupt(64, timer.waiter(100.micros()));
     let (tx, mut tx_it) = tx.into_interrupt(
         32,
-        timer.waiter_us(0.micros(), NonInterval::new()),
-        timer.waiter_us(32 * 200.micros(), NonInterval::new()),
+        timer.waiter(0.micros()),
+        timer.waiter(32 * 200.micros()),
     );
     interrupt_callback.set(mcu, move || {
         rx_it.handler();
@@ -195,17 +195,13 @@ fn uart_dma_init<'r, U: UartPeriphExt + 'static>(
     mcu: &mut Mcu,
     timer: &SystemTimer,
 ) -> UartPollTask<impl embedded_io::Write + 'static, impl embedded_io::Read + 'r> {
-    let uart_rx = rx.into_dma_circle(
-        dma_rx,
-        64,
-        timer.waiter_us(100.micros(), NonInterval::new()),
-    );
+    let uart_rx = rx.into_dma_circle(dma_rx, 64, timer.waiter(100.micros()));
     dma_tx.set_interrupt(DmaEvent::TransferComplete, true);
     let (uart_tx, mut tx_it) = tx.into_dma_ringbuf(
         dma_tx,
         32,
-        timer.waiter_us(0.micros(), NonInterval::new()),
-        timer.waiter_us(32 * 200.micros(), NonInterval::new()),
+        timer.waiter(0.micros()),
+        timer.waiter(32 * 200.micros()),
     );
     interrupt_callback.set(mcu, move || {
         tx_it.interrupt_reload();

src/common/os.rs

@@ -8,4 +8,4 @@ cfg_if::cfg_if! {
     }
 }
 
-pub use waiter_trait::{Waiter, WaiterTime};
+pub use waiter_trait::{Waiter, WaiterStatus};

src/time.rs

@@ -33,15 +33,15 @@ use core::ops;
 use cortex_m::peripheral::{DCB, DWT};
 
 use crate::rcc::Clocks;
-use waiter_trait::{Interval, TickInstant, TickWaiter};
+use waiter_trait::{NonInterval, TickInstant, TickWaiter};
 
 /// Bits per second
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Debug)]
 pub struct Bps(pub u32);
 
 pub use fugit::{
     Duration, HertzU32 as Hertz, KilohertzU32 as KiloHertz, MegahertzU32 as MegaHertz,
-    MicrosDurationU32 as MicroSeconds, MillisDurationU32 as MilliSeconds, NanosDurationU64,
+    MicrosDurationU32 as MicroSeconds, MillisDurationU32 as MilliSeconds,
 };
 
 /// Extension trait that adds convenience methods to the `u32` type
@@ -153,21 +153,8 @@ impl MonoTimer {
         }
     }
 
-    pub fn waiter_us<I: Interval>(
-        &self,
-        timeout: MicroSeconds,
-        interval: I,
-    ) -> TickWaiter<DwtInstant, I, u32> {
-        TickWaiter::us(timeout.ticks(), interval, self.frequency.raw())
-    }
-
-    /// It can wait longer with a nanosecond timeout.
-    pub fn waiter_ns<I: Interval>(
-        &self,
-        timeout: NanosDurationU64,
-        interval: I,
-    ) -> TickWaiter<DwtInstant, I, u64> {
-        TickWaiter::ns(timeout.ticks(), interval, self.frequency.raw())
+    pub fn waiter(&self, timeout: MicroSeconds) -> TickWaiter<DwtInstant, NonInterval, u32> {
+        TickWaiter::us(timeout, NonInterval::new(), self.frequency.raw())
     }
 }
 

src/timer/syst.rs

@@ -4,10 +4,8 @@ use super::*;
 use crate::Mcu;
 use core::ops::{Deref, DerefMut};
 use cortex_m::peripheral::{SYST, syst::SystClkSource};
-use fugit::{
-    HertzU32 as Hertz, MicrosDurationU32, NanosDurationU64, TimerDurationU32, TimerInstantU32,
-};
-use waiter_trait::{Interval, TickInstant, TickWaiter};
+use fugit::{HertzU32 as Hertz, MicrosDurationU32, TimerDurationU32, TimerInstantU32};
+use waiter_trait::{NonInterval, TickInstant, TickWaiter};
 
 pub trait SysTimerInit: Sized {
     /// Creates timer which takes [Hertz] as Duration
@@ -77,21 +75,11 @@ impl SystemTimer {
         self.syst.clear_current();
     }
 
-    pub fn waiter_us<I: Interval>(
+    pub fn waiter(
         &self,
         timeout: MicrosDurationU32,
-        interval: I,
-    ) -> TickWaiter<SysTickInstant, I, u32> {
-        TickWaiter::us(timeout.ticks(), interval, self.clk.raw())
-    }
-
-    /// It can wait longer with a nanosecond timeout.
-    pub fn waiter_ns<I: Interval>(
-        &self,
-        timeout: NanosDurationU64,
-        interval: I,
-    ) -> TickWaiter<SysTickInstant, I, u64> {
-        TickWaiter::ns(timeout.ticks(), interval, self.clk.raw())
+    ) -> TickWaiter<SysTickInstant, NonInterval, u32> {
+        TickWaiter::us(timeout, NonInterval::new(), self.clk.raw())
     }
 }