Use waiter-trait crate

Author: JalonWong

.github/workflows/release.yml

@@ -23,10 +23,10 @@ jobs:
           python-version: "3.13"
       - run: python scripts/sync_code.py --check
       - run: cargo build --release --features=stm32f100,xC
-      - run: cargo build --release --features=stm32f103,xG,rtic
-      - run: cargo clippy --features=stm32f103,xG,rtic
-      - run: cargo test --target=x86_64-unknown-linux-gnu --features=std
-      - run: python scripts/build.py --example=f103c8
+      - run: python scripts/build.py build --release
+      - run: python scripts/build.py clippy
+      - run: python scripts/build.py test
+      - run: python scripts/build.py build --example=f103c8
 
   publish:
     needs: test

.vscode/tasks.json

@@ -10,45 +10,45 @@
             "command": "python",
             "args": [
                 "scripts/build.py",
+                "check"
             ],
             "group": {
                 "kind": "build",
                 "isDefault": true
             },
         },
         {
-            "label": "build",
+            "label": "build_example_f103c8",
             "type": "process",
             "command": "python",
             "args": [
                 "scripts/build.py",
-                "--release"
+                "build",
+                "-e=f103c8",
             ],
             "group": "build",
         },
         {
-            "label": "build_example_f103c8",
+            "label": "test",
             "type": "process",
             "command": "python",
             "args": [
                 "scripts/build.py",
-                "-e",
-                "f103c8"
-            ],
-            "group": "build",
-        },
-        {
-            "label": "Test Windows",
-            "type": "cargo",
-            "command": "test",
-            "args": [
-                "--features=std",
-                "--target=x86_64-pc-windows-msvc",
+                "test"
             ],
             "group": {
                 "kind": "test",
                 "isDefault": true
             },
-        }
+        },
+        {
+            "label": "clippy",
+            "type": "process",
+            "command": "python",
+            "args": [
+                "scripts/build.py",
+                "clippy"
+            ],
+        },
     ]
 }

Cargo.toml

@@ -9,7 +9,7 @@
     name = "stm32f1-hal"
     readme = "README.md"
     repository = "https://github.com/jw-mcu-rust/stm32f1-hal"
-    version = "0.0.5"
+    version = "0.1.0"
 
     [package.metadata.docs.rs]
         features = ["stm32f103", "xG"]
@@ -65,6 +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.4"
 
 [profile.release]
     codegen-units = 1

examples/f103c8/src/led_task.rs

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

examples/f103c8/src/main.rs

@@ -15,12 +15,13 @@ use stm32f1_hal::{
     embedded_io,
     gpio::{Edge, ExtiPin, PinState},
     nvic_scb::PriorityGrouping,
-    os::{RetryTimes, Timeout},
     pac::{self, Interrupt},
     prelude::*,
     rcc,
-    timer::{syst::SysTickTimeout, *},
+    time::MonoTimer,
+    timer::*,
     uart::{self, UartPeriphExt},
+    waiter_trait::{self, Counter, NonInterval, Waiter},
 };
 
 mod led_task;
@@ -58,6 +59,10 @@ fn main() -> ! {
         exti: dp.EXTI,
     };
 
+    let mut sys_timer = cp.SYST.counter_hz(&mcu);
+    sys_timer.start(20.Hz()).unwrap();
+    let mono_timer = MonoTimer::new(cp.DWT, cp.DCB, &mcu.rcc.clocks);
+
     // Keep them in one place for easier management
     mcu.nvic.enable(Interrupt::USART1, false); // Optional
     mcu.nvic.set_priority(Interrupt::USART1, 2);
@@ -88,7 +93,8 @@ fn main() -> ! {
     };
 
     // let mut uart_task = uart_poll_init(uart_tx, uart_rx);
-    // let mut uart_task = uart_interrupt_init(uart_tx, uart_rx, &all_it::USART1_CB, &mut mcu);
+    // let mut uart_task =
+    //     uart_interrupt_init(uart_tx, uart_rx, &all_it::USART1_CB, &mut mcu, &sys_timer);
     dma1.4.set_priority(DmaPriority::Medium);
     dma1.5.set_priority(DmaPriority::Medium);
     let mut uart_task = uart_dma_init(
@@ -98,16 +104,17 @@ fn main() -> ! {
         uart_rx,
         dma1.5,
         &mut mcu,
+        &sys_timer,
     );
 
     // LED --------------------------------------
 
     let mut led = gpiob
         .pb0
         .into_open_drain_output_with_state(&mut gpiob.crl, PinState::High);
-    cp.SYST.counter_hz(&mcu).start(1000.Hz()).unwrap();
-    let mut timeout = SysTickTimeout::new(1000_000);
-    let mut led_task = LedTask::new(led, timeout.start());
+    let mut water = sys_timer.waiter_us(1.secs(), NonInterval::default());
+    // let water = mono_timer.waiter(1.secs());
+    let mut led_task = LedTask::new(led, water.start());
 
     // PWM --------------------------------------
 
@@ -154,8 +161,8 @@ fn uart_poll_init<U: UartPeriphExt>(
     tx: uart::Tx<U>,
     rx: uart::Rx<U>,
 ) -> UartPollTask<impl embedded_io::Write, impl embedded_io::Read> {
-    let uart_rx = rx.into_poll(RetryTimes::new(0), RetryTimes::new(1_000));
-    let uart_tx = tx.into_poll(RetryTimes::new(0), RetryTimes::new(10_000));
+    let uart_rx = rx.into_poll(Counter::new(0), Counter::new(1_000));
+    let uart_tx = tx.into_poll(Counter::new(0), Counter::new(10_000));
     UartPollTask::new(32, uart_tx, uart_rx)
 }
 
@@ -164,10 +171,15 @@ fn uart_interrupt_init<U: UartPeriphExt + 'static>(
     rx: uart::Rx<U>,
     interrupt_callback: &hal::interrupt::Callback,
     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, SysTickTimeout::new(100));
-    let (tx, mut tx_it) =
-        tx.into_interrupt(32, SysTickTimeout::new(0), SysTickTimeout::new(32 * 200));
+    let (rx, mut rx_it) =
+        rx.into_interrupt(64, timer.waiter_us(100.micros(), NonInterval::default()));
+    let (tx, mut tx_it) = tx.into_interrupt(
+        32,
+        timer.waiter_us(0.micros(), NonInterval::default()),
+        timer.waiter_us(32 * 200.micros(), NonInterval::default()),
+    );
     interrupt_callback.set(mcu, move || {
         rx_it.handler();
         tx_it.handler();
@@ -182,14 +194,19 @@ fn uart_dma_init<'r, U: UartPeriphExt + 'static>(
     rx: uart::Rx<U>,
     dma_rx: impl DmaBindRx<U> + 'r,
     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, SysTickTimeout::new(100));
+    let uart_rx = rx.into_dma_circle(
+        dma_rx,
+        64,
+        timer.waiter_us(100.micros(), NonInterval::default()),
+    );
     dma_tx.set_interrupt(DmaEvent::TransferComplete, true);
     let (uart_tx, mut tx_it) = tx.into_dma_ringbuf(
         dma_tx,
         32,
-        SysTickTimeout::new(0),
-        SysTickTimeout::new(32 * 200),
+        timer.waiter_us(0.micros(), NonInterval::default()),
+        timer.waiter_us(32 * 200.micros(), NonInterval::default()),
     );
     interrupt_callback.set(mcu, move || {
         tx_it.interrupt_reload();

examples/f103c8/src/uart_task.rs

@@ -1,5 +1,7 @@
-use crate::embedded_io::{Read, Write};
-use crate::hal::ringbuf::*;
+use crate::{
+    embedded_io::{Read, Write},
+    hal::ringbuf::*,
+};
 
 pub struct UartPollTask<W: Write, R: Read> {
     tx: W,

scripts/build.py

@@ -1,5 +1,6 @@
 import argparse
 import os
+import platform
 import subprocess
 
 from base import green
@@ -13,26 +14,32 @@ def run_cmd(cmd: list[str]) -> None:
 
 def main() -> int:
     parser = argparse.ArgumentParser()
+    parser.add_argument("cmd", choices=["check", "test", "build", "clippy"])
     parser.add_argument("--release", action="store_true")
     parser.add_argument("--features", type=str, nargs="*")
     parser.add_argument("-e", "--examples", type=str, nargs="*")
     opts = parser.parse_args()
 
     sync_all()
 
-    cmd = ["cargo"]
+    cmd = ["cargo", opts.cmd]
 
     if opts.examples:
         for e in opts.examples:
             os.chdir("examples/" + e)
-            cmd.extend(["build", "--release"])
+            cmd.append("--release")
             run_cmd(cmd)
             os.chdir("../../")
+    elif opts.cmd == "test":
+        cmd.append("--features=std")
+        if platform.system().lower() == "windows":
+            cmd.append("--target=x86_64-pc-windows-msvc")
+        else:
+            cmd.append("--target=x86_64-unknown-linux-gnu")
+        run_cmd(cmd)
     else:
         if opts.release:
-            cmd.extend(["build", "--release"])
-        else:
-            cmd.append("check")
+            cmd.append("--release")
 
         if opts.features is None:
             cmd.append(f"--features=stm32f103,xG,rtic")

src/common/os.rs

@@ -8,86 +8,4 @@ cfg_if::cfg_if! {
     }
 }
 
-#[inline(always)]
-pub fn yield_cpu() {
-    // TODO yield
-}
-
-pub trait Timeout {
-    fn start(&mut self) -> impl TimeoutInstance;
-}
-
-pub trait TimeoutInstance {
-    fn timeout(&mut self) -> bool;
-    fn restart(&mut self);
-    fn interval(&self);
-}
-
-// Retry ----------------------------------
-
-pub struct RetryTimes {
-    retry_times: usize,
-}
-impl RetryTimes {
-    pub fn new(retry_times: usize) -> Self {
-        Self { retry_times }
-    }
-}
-impl Timeout for RetryTimes {
-    #[inline]
-    fn start(&mut self) -> impl TimeoutInstance {
-        RetryTimesInstance {
-            count: 0,
-            retry_times: self.retry_times,
-        }
-    }
-}
-
-pub struct RetryTimesInstance {
-    count: usize,
-    retry_times: usize,
-}
-impl TimeoutInstance for RetryTimesInstance {
-    #[inline]
-    fn timeout(&mut self) -> bool {
-        if self.count <= self.retry_times {
-            self.count = self.count.wrapping_add(1);
-            false
-        } else {
-            true
-        }
-    }
-
-    #[inline(always)]
-    fn restart(&mut self) {
-        self.count = 0;
-    }
-
-    #[inline(always)]
-    fn interval(&self) {}
-}
-
-// Always ----------------------------------
-
-#[derive(Default)]
-pub struct AlwaysTimeout {}
-impl Timeout for AlwaysTimeout {
-    #[inline]
-    fn start(&mut self) -> impl TimeoutInstance {
-        AlwaysTimeoutInstance {}
-    }
-}
-
-pub struct AlwaysTimeoutInstance {}
-impl TimeoutInstance for AlwaysTimeoutInstance {
-    #[inline(always)]
-    fn timeout(&mut self) -> bool {
-        true
-    }
-
-    #[inline(always)]
-    fn restart(&mut self) {}
-
-    #[inline(always)]
-    fn interval(&self) {}
-}
+pub use waiter_trait::{Waiter, WaiterTime};