rtic_monotonics/
systick.rs

Help
1//! [`Monotonic`](rtic_time::Monotonic) based on Cortex-M SysTick.
2//! Note: this implementation is inefficient as it
3//! ticks and generates interrupts at a constant rate.
4//!
5//! # Example
6//!
7//! ```
8//! use rtic_monotonics::systick::prelude::*;
9//! systick_monotonic!(Mono, 1_000);
10//!
11//! fn init() {
12//!     # // This is normally provided by the selected PAC
13//!     # let systick = unsafe { core::mem::transmute(()) };
14//!     #
15//!     // Start the monotonic
16//!     Mono::start(systick, 12_000_000);
17//! }
18//!
19//! async fn usage() {
20//!     loop {
21//!          // Use the monotonic
22//!          let timestamp = Mono::now();
23//!          Systick::delay(100.millis()).await;
24//!     }
25//! }
26//! ```
27
28/// Common definitions and traits for using the systick monotonic
29pub mod prelude {
30    pub use crate::systick_monotonic;
31
32    pub use crate::Monotonic;
33
34    cfg_if::cfg_if! {
35        if #[cfg(feature = "systick-64bit")] {
36            pub use fugit::{self, ExtU64, ExtU64Ceil};
37        } else {
38            pub use fugit::{self, ExtU32, ExtU32Ceil};
39        }
40    }
41}
42
43pub use cortex_m::peripheral::SYST;
44
45use portable_atomic::Ordering;
46use rtic_time::timer_queue::TimerQueue;
47
48use crate::TimerQueueBackend;
49
50cfg_if::cfg_if! {
51    if #[cfg(feature = "systick-64bit")] {
52        use portable_atomic::AtomicU64;
53        static SYSTICK_CNT: AtomicU64 = AtomicU64::new(0);
54    } else {
55        use portable_atomic::AtomicU32;
56        static SYSTICK_CNT: AtomicU32 = AtomicU32::new(0);
57    }
58}
59
60static SYSTICK_TIMER_QUEUE: TimerQueue<SystickBackend> = TimerQueue::new();
61
62/// Systick based [`TimerQueueBackend`].
63pub struct SystickBackend;
64
65impl SystickBackend {
66    /// Starts the monotonic timer.
67    ///
68    /// **Do not use this function directly.**
69    ///
70    /// Use the prelude macros instead.
71    pub fn _start(mut systick: SYST, sysclk: u32, timer_hz: u32) {
72        assert!(
73            (sysclk % timer_hz) == 0,
74            "timer_hz cannot evenly divide sysclk! Please adjust the timer or sysclk frequency."
75        );
76        let reload = sysclk / timer_hz - 1;
77
78        assert!(reload <= 0x00ff_ffff);
79        assert!(reload > 0);
80
81        systick.disable_counter();
82        systick.set_clock_source(cortex_m::peripheral::syst::SystClkSource::Core);
83        systick.set_reload(reload);
84        systick.enable_interrupt();
85        systick.enable_counter();
86
87        SYSTICK_TIMER_QUEUE.initialize(SystickBackend {});
88    }
89
90    fn systick() -> SYST {
91        unsafe { core::mem::transmute::<(), SYST>(()) }
92    }
93}
94
95impl TimerQueueBackend for SystickBackend {
96    cfg_if::cfg_if! {
97        if #[cfg(feature = "systick-64bit")] {
98            type Ticks = u64;
99        } else {
100            type Ticks = u32;
101        }
102    }
103
104    fn now() -> Self::Ticks {
105        if Self::systick().has_wrapped() {
106            SYSTICK_CNT.fetch_add(1, Ordering::AcqRel);
107        }
108
109        SYSTICK_CNT.load(Ordering::Relaxed)
110    }
111
112    fn set_compare(_: Self::Ticks) {
113        // No need to do something here, we get interrupts anyway.
114    }
115
116    fn clear_compare_flag() {
117        // NOOP with SysTick interrupt
118    }
119
120    fn pend_interrupt() {
121        cortex_m::peripheral::SCB::set_pendst();
122    }
123
124    fn on_interrupt() {
125        if Self::systick().has_wrapped() {
126            SYSTICK_CNT.fetch_add(1, Ordering::AcqRel);
127        }
128    }
129
130    fn timer_queue() -> &'static TimerQueue<Self> {
131        &SYSTICK_TIMER_QUEUE
132    }
133}
134
135/// Create a Systick based monotonic and register the Systick interrupt for it.
136///
137/// See [`crate::systick`] for more details.
138///
139/// # Arguments
140///
141/// * `name` - The name that the monotonic type will have.
142/// * `tick_rate_hz` - The tick rate of the timer peripheral.
143///   Can be omitted; defaults to 1kHz.
144#[macro_export]
145macro_rules! systick_monotonic {
146    ($name:ident) => {
147        $crate::systick_monotonic!($name, 1_000);
148    };
149    ($name:ident, $tick_rate_hz:expr) => {
150        /// A `Monotonic` based on SysTick.
151        pub struct $name;
152
153        impl $name {
154            /// Starts the `Monotonic`.
155            ///
156            /// The `sysclk` parameter is the speed at which SysTick runs at. This value should come from
157            /// the clock generation function of the used HAL.
158            ///
159            /// Panics if it is impossible to achieve the desired monotonic tick rate based
160            /// on the given `sysclk` parameter. If that happens, adjust the desired monotonic tick rate.
161            ///
162            /// This method must be called only once.
163            pub fn start(systick: $crate::systick::SYST, sysclk: u32) {
164                #[no_mangle]
165                #[allow(non_snake_case)]
166                unsafe extern "C" fn SysTick() {
167                    use $crate::TimerQueueBackend;
168                    $crate::systick::SystickBackend::timer_queue().on_monotonic_interrupt();
169                }
170
171                $crate::systick::SystickBackend::_start(systick, sysclk, $tick_rate_hz);
172            }
173        }
174
175        impl $crate::TimerQueueBasedMonotonic for $name {
176            type Backend = $crate::systick::SystickBackend;
177            type Instant = $crate::fugit::Instant<
178                <Self::Backend as $crate::TimerQueueBackend>::Ticks,
179                1,
180                { $tick_rate_hz },
181            >;
182            type Duration = $crate::fugit::Duration<
183                <Self::Backend as $crate::TimerQueueBackend>::Ticks,
184                1,
185                { $tick_rate_hz },
186            >;
187        }
188
189        $crate::rtic_time::impl_embedded_hal_delay_fugit!($name);
190        $crate::rtic_time::impl_embedded_hal_async_delay_fugit!($name);
191    };
192}
rtic_monotonics/systick.rs

rtic_monotonics/
systick.rs
