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.6"
 
 [profile.release]
     codegen-units = 1

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/time.rs

@@ -33,15 +33,16 @@ 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, NanosDurationU32,
+    NanosDurationU64,
 };
 
 /// Extension trait that adds convenience methods to the `u32` type
@@ -153,21 +154,16 @@ 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())
+    pub fn waiter(&self, timeout: NanosDurationU32) -> TickWaiter<DwtInstant, NonInterval, u32> {
+        TickWaiter::new(timeout, NonInterval::new(), self.frequency.raw())
     }
 
-    /// It can wait longer with a nanosecond timeout.
-    pub fn waiter_ns<I: Interval>(
+    /// It can wait longer.
+    pub fn waiter_u64(
         &self,
         timeout: NanosDurationU64,
-        interval: I,
-    ) -> TickWaiter<DwtInstant, I, u64> {
-        TickWaiter::ns(timeout.ticks(), interval, self.frequency.raw())
+    ) -> TickWaiter<DwtInstant, NonInterval, u64> {
+        TickWaiter::new_u64(timeout, NonInterval::new(), self.frequency.raw())
     }
 }
 

src/timer/syst.rs

@@ -5,9 +5,9 @@ use crate::Mcu;
 use core::ops::{Deref, DerefMut};
 use cortex_m::peripheral::{SYST, syst::SystClkSource};
 use fugit::{
-    HertzU32 as Hertz, MicrosDurationU32, NanosDurationU64, TimerDurationU32, TimerInstantU32,
+    HertzU32 as Hertz, NanosDurationU32, NanosDurationU64, TimerDurationU32, TimerInstantU32,
 };
-use waiter_trait::{Interval, TickInstant, TickWaiter};
+use waiter_trait::{NonInterval, TickInstant, TickWaiter};
 
 pub trait SysTimerInit: Sized {
     /// Creates timer which takes [Hertz] as Duration
@@ -77,21 +77,19 @@ 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())
+        timeout: NanosDurationU32,
+    ) -> TickWaiter<SysTickInstant, NonInterval, u32> {
+        TickWaiter::new(timeout, NonInterval::new(), self.clk.raw())
     }
 
-    /// It can wait longer with a nanosecond timeout.
-    pub fn waiter_ns<I: Interval>(
+    /// It can wait longer.
+    pub fn waiter_u64(
         &self,
         timeout: NanosDurationU64,
-        interval: I,
-    ) -> TickWaiter<SysTickInstant, I, u64> {
-        TickWaiter::ns(timeout.ticks(), interval, self.clk.raw())
+    ) -> TickWaiter<SysTickInstant, NonInterval, u64> {
+        TickWaiter::new_u64(timeout, NonInterval::new(), self.clk.raw())
     }
 }