Merge pull request #40 from niclashoyer/timers

Add mock for timers

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
  strategy:
  matrix:
  toolchain:
- - "1.56"
+ - "1.60"
  - "nightly"
  steps:
  - uses: actions/checkout@v3
@@ -35,19 +35,20 @@ jobs:
  rustc --version
  cargo --version
 
- # Build main crate
- - name: Build
- run: cargo build
- - name: Build (all features)
- if: ${{ matrix.toolchain == 'nightly' }}
- run: cargo build --all-features
+ # Check crate
+ - name: Check
+ run: cargo check
+ - name: Check (no default features)
+ run: cargo check --no-default-features
+ - name: Check (all features)
+ run: cargo check --all-features
 
- # Test main crate
+ # Test crate
  - name: Test
- if: ${{ matrix.toolchain != 'nightly' }} 
  run: cargo test
+ - name: Test (no default features)
+ run: cargo test --no-default-features
  - name: Test (all features)
- if: ${{ matrix.toolchain == 'nightly' }}
  run: cargo test --all-features
 
  # Check code formatting

Cargo.toml

@@ -21,4 +21,10 @@ edition = "2021"
 
 [dependencies]
 embedded-hal = { version = "0.2.7", features = ["unproven"] }
+embedded-time = { version = "0.12", optional = true }
+void = { version = "^1.0", optional = true }
 nb = "0.1.1"
+
+[features]
+default = ["embedded-time"]
+embedded-time = ["dep:embedded-time", "dep:void"]

README.md

@@ -17,7 +17,7 @@ or no-op implementations are used.
 The goal of the crate is to be able to test drivers in CI without having access
 to hardware.
 
-This crate requires Rust 1.56+!
+This crate requires Rust 1.60+!
 
 [Docs](https://docs.rs/embedded-hal-mock/)
 
@@ -32,7 +32,7 @@ This crate requires Rust 1.56+!
 - [ ] RNG
 - [x] I/O pins (including PWM)
 - [x] ADC
-- [ ] Timers
+- [x] Timers (with `embedded-time` Cargo feature)
 - [ ] ...
 
 Pull requests for more mock implementations are welcome! :)

clippy.toml

@@ -1 +1 @@
-msrv = "1.56"
+msrv = "1.60"

src/lib.rs

@@ -10,6 +10,12 @@
 //!
 //! See module-level docs for more information.
 //!
+//! ## Cargo Features
+//!
+//! There are currently the following cargo features:
+//!
+//! - `embedded-time`: Enable the `timer` module (enabled by default)
+//!
 //! ## no\_std
 //!
 //! Currently this crate is not `no_std`. If you think this is important, let
@@ -27,3 +33,5 @@ pub mod i2c;
 pub mod pin;
 pub mod serial;
 pub mod spi;
+#[cfg(feature = "embedded-time")]
+pub mod timer;

src/timer.rs

@@ -0,0 +1,160 @@
+//! Provides a mocked [embedded_time::Clock] that can be used for host-side testing
+//! crates that use [embedded_hal::timer].
+//!
+//! The provided [embedded_time::Clock] implementation is thread safe and can be freely
+//! skipped forward with nanosecond precision.
+//!
+//! # Usage
+//!
+//! ```rust
+//! use embedded_hal::timer::CountDown;
+//! use embedded_time::duration::*;
+//! use embedded_hal_mock::timer::MockClock;
+//!
+//! let mut clock = MockClock::new();
+//! let mut timer = clock.get_timer();
+//! timer.start(100.nanoseconds());
+//! // hand over timer to embedded-hal based driver
+//! // continue to tick clock
+//! clock.tick(50.nanoseconds());
+//! assert_eq!(timer.wait(), Err(nb::Error::WouldBlock));
+//! clock.tick(50.nanoseconds());
+//! assert_eq!(timer.wait(), Ok(()));
+//! clock.tick(50.nanoseconds());
+//! assert_eq!(timer.wait(), Err(nb::Error::WouldBlock));
+//! clock.tick(50.nanoseconds());
+//! assert_eq!(timer.wait(), Ok(()));
+//! ```
+
+use std::{
+ convert::Infallible,
+ sync::{
+ atomic::{AtomicU64, Ordering},
+ Arc,
+ },
+};
+use void::Void;
+
+use embedded_hal::timer::{Cancel, CountDown, Periodic};
+pub use embedded_time::Clock;
+use embedded_time::{clock, duration::*, fraction::Fraction, Instant};
+
+/// A simulated clock that can be used in tests.
+#[derive(Clone, Debug)]
+pub struct MockClock {
+ ticks: Arc<AtomicU64>,
+}
+
+impl Clock for MockClock {
+ type T = u64;
+ const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000_000_000);
+
+ fn try_now(&self) -> Result<Instant<Self>, clock::Error> {
+ let ticks: u64 = self.ticks.load(Ordering::Relaxed);
+ Ok(Instant::<Self>::new(ticks))
+ }
+}
+
+impl Default for MockClock {
+ fn default() -> Self {
+ MockClock {
+ ticks: Arc::new(AtomicU64::new(0)),
+ }
+ }
+}
+
+impl MockClock {
+ /// Creates a new simulated clock.
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Returns the number of elapsed nanoseconds.
+ pub fn elapsed(&self) -> Nanoseconds<u64> {
+ Nanoseconds(self.ticks.load(Ordering::Relaxed))
+ }
+
+ /// Forward the clock by `ticks` amount.
+ pub fn tick<T>(&mut self, ticks: T)
+ where
+ T: Into<Nanoseconds<u64>>,
+ {
+ self.ticks.fetch_add(ticks.into().0, Ordering::Relaxed);
+ }
+
+ /// Get a new timer based on the clock.
+ pub fn get_timer(&self) -> MockTimer {
+ let clock = self.clone();
+ let duration = Nanoseconds(1);
+ let expiration = clock.try_now().unwrap();
+ MockTimer {
+ clock: self.clone(),
+ duration,
+ expiration,
+ started: false,
+ }
+ }
+}
+
+/// A simulated timer that can be used in tests.
+pub struct MockTimer {
+ clock: MockClock,
+ duration: Nanoseconds<u64>,
+ expiration: Instant<MockClock>,
+ started: bool,
+}
+
+impl CountDown for MockTimer {
+ type Time = Nanoseconds<u64>;
+
+ fn start<T>(&mut self, count: T)
+ where
+ T: Into<Self::Time>,
+ {
+ let now = self.clock.try_now().unwrap();
+ self.duration = count.into();
+ self.expiration = now + self.duration;
+ self.started = true;
+ }
+
+ fn wait(&mut self) -> nb::Result<(), Void> {
+ let now = self.clock.try_now().unwrap();
+ if self.started && now >= self.expiration {
+ self.expiration = now + self.duration;
+ Ok(())
+ } else {
+ Err(nb::Error::WouldBlock)
+ }
+ }
+}
+
+impl Periodic for MockTimer {}
+
+impl Cancel for MockTimer {
+ type Error = Infallible;
+
+ fn cancel(&mut self) -> Result<(), Self::Error> {
+ self.started = false;
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn count_down() {
+ let mut clock = MockClock::new();
+ let mut timer = clock.get_timer();
+ timer.start(100.nanoseconds());
+ clock.tick(50.nanoseconds());
+ assert_eq!(timer.wait(), Err(nb::Error::WouldBlock));
+ clock.tick(50.nanoseconds());
+ assert_eq!(timer.wait(), Ok(()));
+ clock.tick(50.nanoseconds());
+ assert_eq!(timer.wait(), Err(nb::Error::WouldBlock));
+ clock.tick(50.nanoseconds());
+ assert_eq!(timer.wait(), Ok(()));
+ }
+}