时间驱动

pub trait Driver: Send + Sync + 'static {
    /// Return the current timestamp in ticks.
    ///
    /// Implementations MUST ensure that:
    /// - This is guaranteed to be monotonic, ...
    /// - It "never" overflows. It must not overflow in a sufficiently long time frame, say
    ///   in 10_000 years ...
    /// - It never fails, including any kind of access fault, even if the underlying
    ///   hardware has not yet been initialized. ...
    fn now(&self) -> u64;

    /// Schedules a waker to be awoken at moment `at`.
    /// If this moment is in the past, the waker might be awoken immediately.
    fn schedule_wake(&self, at: u64, waker: &Waker);
}

unsafe extern "Rust" {
    fn _embassy_time_now() -> u64;
    fn _embassy_time_schedule_wake(at: u64, waker: &Waker);
}

/// See [`Driver::now`]
#[inline]
pub fn now() -> u64 {
    unsafe { _embassy_time_now() }
}

macro_rules! time_driver_impl {
    (static $name:ident: $t: ty = $val:expr) => {
        static $name: $t = $val;

        #[unsafe(no_mangle)]
        #[inline]
        fn _embassy_time_now() -> u64 {
            <$t as $crate::Driver>::now(&$name)
        }

        #[unsafe(no_mangle)]
        #[inline]
        fn _embassy_time_schedule_wake(at: u64, waker: &core::task::Waker) {
            <$t as $crate::Driver>::schedule_wake(&$name, at, waker);
        }
    };
}

  = note: Undefined symbols for architecture arm64:
            "__embassy_time_now", referenced from:
                __RNvCs4QyoBtEmjrB_19embassy_time_driver3nowCsbLvIQ9Pi7Qd_13time_nodriver in time_nodriver-b44d07e8b282199e.6pak1aiwlh9sm41v6kc2xa594.1jgbfpu.rcgu.o
          ld: symbol(s) not found for architecture arm64

error: symbol `_embassy_time_now` is already defined
  --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/embassy-time-0.5.1/src/driver_std.rs:20:1
   |
20 | / embassy_time_driver::time_driver_impl!(static DRIVER: TimeDriver = TimeDriver {

  = note: rust-lld: error: duplicate symbol: _embassy_time_now
          >>> defined at lib.rs:168 (~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/embassy-time-driver-0.2.2/src/lib.rs:168)
          >>>            ~/exp-embassy/target-time-qemu/thumbv7em-none-eabihf/release/deps/q_dup-f40f6542ce07c317.q_dup.5d0c0467d7d93bf3-cgu.0.rcgu.o:(_embassy_time_now)
          >>> defined at lib.rs:168 (~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/embassy-time-driver-0.2.2/src/lib.rs:168)
          >>>            embassy_stm32-0c67ec75b754013f.embassy_stm32.fd2545e22b51d66f-cgu.2.rcgu.o:(.text._embassy_time_now+0x1) in archive ~/exp-embassy/target-time-qemu/thumbv7em-none-eabihf/release/deps/libembassy_stm32-0c67ec75b754013f.rlib

warning: linker stderr: ld: duplicate symbol '__embassy_time_now' in:
         ~/exp-embassy/target-time-std/debug/deps/time_dup-dae997501625b2d0.ckzz2bx5tp2e61jvhw1xx4j39.0va4dfb.rcgu.o
         ~/exp-embassy/target-time-std/debug/deps/libembassy_time-37093cb091fae193.rlib[4](embassy_time-37093cb091fae193.embassy_time.6329b00ed89fe955-cgu.0.rcgu.o)

    fn schedule_wake(&self, at: u64, waker: &Waker) {
        critical_section::with(|cs| {
            let mut queue = self.queue.borrow(cs).borrow_mut();
            if queue.schedule_wake(at, waker) {
                let mut next = queue.next_expiration(self.now());
                while !self.set_alarm(&cs, next) {
                    next = queue.next_expiration(self.now());
                }
            }
        });
    }

fn alarm_thread() {
    let zero = DRIVER.inner.lock().unwrap().zero_instant.unwrap();
    loop {
        let now = DRIVER.now();

        let next_alarm = DRIVER.inner.lock().unwrap().queue.next_expiration(now);

        // Ensure we don't overflow
        let until = zero
            .checked_add(StdDuration::from_micros(next_alarm))
            .unwrap_or_else(|| StdInstant::now() + StdDuration::from_secs(1));

        DRIVER.signaler.wait_until(until);
    }
}

    pub fn advance(&self, duration: Duration) {
        critical_section::with(|cs| {
            let inner = &mut *self.0.borrow_ref_mut(cs);

            inner.now += duration;
            // wake expired tasks.
            inner.queue.next_expiration(inner.now.as_ticks());
        })
    }

running 2 tests
after 350 ms: 3 ticks ready at once, wakes so far 0
after 399 ms: wakes 0
after 400 ms: wakes 1
.at 99.999 ms: wakes 0, poll Pending
at 100.000 ms: wakes 1, poll Ready(Err(TimeoutError))
now = 100000 ticks
.
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

---- tests::ticker_catches_up stdout ----
after 350 ms: 4 ticks ready at once, wakes so far 0
...
assertion `left == right` failed
  left: 4
 right: 3

            let timeout = (timestamp - now) as u32;
            let closure = self.closure.get_or_insert_with(|| Closure::new(dispatch));
            self.alarm.token = Some(setTimeout(closure, timeout / 1000));

        let timer_freq = T::frequency();

        r.cr1().modify(|w| w.set_cen(false));
        r.cnt().write(|w| w.set_cnt(0));

        let psc = timer_freq.0 / TICK_HZ as u32 - 1;
        let psc: u16 = match psc.try_into() {
            Err(_) => panic!("psc division overflow: {}", psc),
            Ok(n) => n,
        };

        r.psc().write_value(psc);
        r.arr().write(|w| w.set_arr(u16::MAX));
        // ...
        // Mid-way point
        r.ccr(0).write(|w| w.set_ccr(0x8000));

        // Enable overflow and half-overflow interrupts
        r.dier().write(|w| {
            w.set_uie(true);
            w.set_ccie(0, true);
        });

fn calc_now(period: u32, counter: u16) -> u64 {
    ((period as u64) << 15) + ((counter as u32 ^ ((period & 1) << 15)) as u64)
}

masked   1000 ticks: now()-true min       0 max   0, after recovery       0
masked  32767 ticks: now()-true min       0 max   0, after recovery       0
masked  36864 ticks: now()-true min       0 max   0, after recovery       0
masked  36865 ticks: now()-true min  -65536 max   0, after recovery       0
masked  65536 ticks: now()-true min  -65536 max   0, after recovery       0
masked 100000 ticks: now()-true min  -65536 max   0, after recovery       0
masked 102400 ticks: now()-true min  -65536 max   0, after recovery  -65536
masked 102401 ticks: now()-true min -131072 max   0, after recovery  -65536
masked 200000 ticks: now()-true min -196608 max   0, after recovery -131072

        let t = self.now();
        if timestamp <= t {
            // If alarm timestamp has passed the alarm will not fire.
            // Disarm the alarm and return `false` to indicate that.
            r.dier().modify(|w| w.set_ccie(n + 1, false));

            self.alarm.borrow(cs).timestamp.set(u64::MAX);

            return false;
        }

        // Write the CCR value regardless of whether we're going to enable it now or not.
        // This way, when we enable it later, the right value is already set.
        r.ccr(n + 1).write(|w| w.set_ccr(timestamp as u16));

        // Enable it if it'll happen soon. Otherwise, `next_period` will enable it.
        let diff = timestamp - t;
        r.dier().modify(|w| w.set_ccie(n + 1, diff < 0xc000));

        // Reevaluate if the alarm timestamp is still in the future
        let t = self.now();
        if timestamp <= t {
            // ...
            r.dier().modify(|w| w.set_ccie(n + 1, false));
            self.alarm.borrow(cs).timestamp.set(u64::MAX);
            return false;
        }

before init, TICK_HZ 1000
init done, now 0 ticks
after busy loop, now 0 ticks
awaiting Timer::after_millis(10)
[runq: killed after 10s]

impl embassy_time_driver::Driver for SysTickDriver {
  fn now(&self) -> u64 {
    critical_section::with(|cs| self.ticks.borrow(cs).get())
  }
  fn schedule_wake(&self, at: u64, waker: &Waker) {
    critical_section::with(|cs| {
      self.queue.borrow(cs).borrow_mut().schedule_wake(at, waker);
    });
  }
}

#[exception]
fn SysTick() {
  critical_section::with(|cs| {
    let t = DRIVER.ticks.borrow(cs).get() + 1;
    DRIVER.ticks.borrow(cs).set(t);
    DRIVER.queue.borrow(cs).borrow_mut().next_expiration(t);
  });
}

started near end of tick  : Timer::after_micros(1000) waited 269 us
started near start of tick: Timer::after_micros(1000) waited 1264 us
started near end of tick  : Timer::after_micros(1500) waited 1521 us
started near start of tick: Timer::after_micros(1500) waited 2522 us
started near end of tick  : Timer::after_micros(1) waited 266 us
one Timer::after_millis(1000): 1000 SysTick interrupts

spin(200000): interrupts on 9 ticks, inside critical_section 1 ticks
spin(2000000): interrupts on 96 ticks, inside critical_section 1 ticks

block_for(5ms) outside critical section: 5 ticks
block_for(5ms) inside critical section ...
[runq: killed after 10s]