Updated the monotonic impl chapter
@@ -6,36 +6,42 @@ implement the [`rtic_monotonic::Monotonic`] trait.
Implementing time that supports a vast range is generally **very** difficult, and in RTIC 0.5 it was a
common problem how to implement time handling and not get stuck in weird special cases. Moreover
-it was difficult to understand the relation between time and the timers used for scheduling. From
-RTIC 0.6 we have moved to use [`embedded_time`] as the basis for all time-based operation and
-abstraction of clocks. This is why from RTIC 0.6 it is almost trivial to implement the `Monotonic`
-trait and use any timer in a system for scheduling.
+it was difficult to understand the relation between time and the timers used for scheduling. For
+RTIC 0.6 we have moved to assume the user has a time library, e.g. [`fugit`] or [`embedded_time`],
+as the basis for all time-based operations when implementing `Monotonic`. This is why in RTIC 0.6
+it is almost trivial to implement the `Monotonic` trait and use any timer in a system for scheduling.
The trait documents the requirements for each method, however a small PoC implementation is provided
below.
[`rtic_monotonic::Monotonic`]: https://docs.rs/rtic-monotonic/
+[`fugit`]: https://docs.rs/fugit/
[`embedded_time`]: https://docs.rs/embedded_time/
```rust
-use rtic_monotonic::{embedded_time::clock::Error, Clock, Fraction, Instant, Monotonic};
+pub use fugit::{self, ExtU32};
+use rtic_monotonic::Monotonic;
/// Example wrapper struct for a timer
-pub struct Timer<const FREQ: u32> {
+pub struct Timer<const TIMER_HZ: u32> {
tim: TIM2,
}
-impl<const FREQ: u32> Clock for Timer<FREQ> {
- const SCALING_FACTOR: Fraction = Fraction::new(1, FREQ);
- type T = u32;
+impl<const TIMER_HZ: u32> Monotonic for Timer<TIMER_HZ> {
+ type Instant = fugit::TimerInstantU32<TIMER_HZ>;
+ type Duration = fugit::TimerDurationU32<TIMER_HZ>;
- #[inline(always)]
- fn try_now(&self) -> Result<Instant<Self>, Error> {
- Ok(Instant::new(Self::count()))
+ fn now(&mut self) -> Self::Instant {
+ // Read the timer count
+ Self::Instant::from_ticks(Self::count())
}
+
+ fn zero() -> Self::Instant {
+ // This is used while the app is in `#[init]`, if the system cannot
+ // support time in `#[init]` this can also be a `panic!(..)`
+ Self::Instant::from_ticks(0)
}
-impl Monotonic for Timer<TIM2> {
unsafe fn reset(&mut self) {
// Reset timer counter
self.tim.cnt.write(|_, w| w.bits(0));
@@ -45,11 +51,11 @@ impl Monotonic for Timer<TIM2> {
self.tim.dier.modify(|_, w| w.cc1ie().set_bit());
}
+ fn set_compare(&mut self, instant: Instant<Self>) {
// Use Compare channel 1 for Monotonic
- fn set_compare(&mut self, instant: &Instant<Self>) {
self.tim
.ccr1
- .write(|w| w.ccr().bits(instant.duration_since_epoch().integer()));
+ .write(|w| w.ccr().bits(instant.ticks()));
}
fn clear_compare_flag(&mut self) {
