From 8963e0e27ae57f7a8c3a666fe9e5a993cdd09275 Mon Sep 17 00:00:00 2001 From: Emil Fresk Date: Fri, 10 Feb 2023 07:52:50 +0100 Subject: RP2040 monotonic, rename systick monotonic to not have double name --- rtic-monotonics/Cargo.toml | 5 + rtic-monotonics/src/lib.rs | 5 +- rtic-monotonics/src/rp2040.rs | 143 +++++++++++++++++++++++++++ rtic-monotonics/src/systick.rs | 163 +++++++++++++++++++++++++++++++ rtic-monotonics/src/systick_monotonic.rs | 163 ------------------------------- 5 files changed, 315 insertions(+), 164 deletions(-) create mode 100644 rtic-monotonics/src/rp2040.rs create mode 100644 rtic-monotonics/src/systick.rs delete mode 100644 rtic-monotonics/src/systick_monotonic.rs (limited to 'rtic-monotonics') diff --git a/rtic-monotonics/Cargo.toml b/rtic-monotonics/Cargo.toml index 4014fe7..2e75bdb 100644 --- a/rtic-monotonics/Cargo.toml +++ b/rtic-monotonics/Cargo.toml @@ -23,7 +23,12 @@ fugit = { version = "0.3.6", features = ["defmt"] } rtic-time = { version = "1.0.0-alpha.0", path = "../rtic-time" } atomic-polyfill = "1" cfg-if = "1.0.0" +rp2040-pac = { version = ">=0.2.0,<0.5", optional = true } [features] +default = [] + systick_100hz = [] systick_10khz = [] + +rp2040 = ["dep:rp2040-pac"] diff --git a/rtic-monotonics/src/lib.rs b/rtic-monotonics/src/lib.rs index 1e23088..fb5dc8a 100644 --- a/rtic-monotonics/src/lib.rs +++ b/rtic-monotonics/src/lib.rs @@ -9,4 +9,7 @@ pub use rtic_time::{Monotonic, TimeoutError, TimerQueue}; -pub mod systick_monotonic; +pub mod systick; + +#[cfg(feature = "rp2040")] +pub mod rp2040; diff --git a/rtic-monotonics/src/rp2040.rs b/rtic-monotonics/src/rp2040.rs new file mode 100644 index 0000000..448c388 --- /dev/null +++ b/rtic-monotonics/src/rp2040.rs @@ -0,0 +1,143 @@ +//! A monotonic implementation for RP2040's Timer peripheral. + +use super::Monotonic; +pub use super::{TimeoutError, TimerQueue}; +use core::future::Future; +use embedded_hal_async::delay::DelayUs; +pub use fugit::ExtU64; +use rp2040_pac::{timer, Interrupt, RESETS, TIMER}; + +/// Timer implementing `rtic_monotonic::Monotonic` which runs at 1 MHz. +pub struct Timer; + +impl Timer { + /// Start a `Monotonic` based on RP2040's Timer. + pub fn start(timer: TIMER, resets: &mut RESETS) { + resets.reset.modify(|_, w| w.timer().clear_bit()); + while resets.reset_done.read().timer().bit_is_clear() {} + timer.inte.modify(|_, w| w.alarm_0().set_bit()); + + TIMER_QUEUE.initialize(Self {}); + } + + fn timer() -> &'static timer::RegisterBlock { + unsafe { &*TIMER::ptr() } + } +} + +static TIMER_QUEUE: TimerQueue = TimerQueue::new(); + +// Forward timerqueue interface +impl Timer { + /// Used to access the underlying timer queue + #[doc(hidden)] + pub fn __tq() -> &'static TimerQueue { + &TIMER_QUEUE + } + + /// Timeout at a specific time. + pub async fn timeout_at( + instant: ::Instant, + future: F, + ) -> Result { + TIMER_QUEUE.timeout_at(instant, future).await + } + + /// Timeout after a specific duration. + #[inline] + pub async fn timeout_after( + duration: ::Duration, + future: F, + ) -> Result { + TIMER_QUEUE.timeout_after(duration, future).await + } + + /// Delay for some duration of time. + #[inline] + pub async fn delay(duration: ::Duration) { + TIMER_QUEUE.delay(duration).await; + } + + /// Delay to some specific time instant. + pub async fn delay_until(instant: ::Instant) { + TIMER_QUEUE.delay_until(instant).await; + } +} + +impl Monotonic for Timer { + type Instant = fugit::TimerInstantU64<1_000_000>; + type Duration = fugit::TimerDurationU64<1_000_000>; + + const ZERO: Self::Instant = Self::Instant::from_ticks(0); + + fn now() -> Self::Instant { + let timer = Self::timer(); + + let mut hi0 = timer.timerawh.read().bits(); + loop { + let low = timer.timerawl.read().bits(); + let hi1 = timer.timerawh.read().bits(); + if hi0 == hi1 { + break Self::Instant::from_ticks((u64::from(hi0) << 32) | u64::from(low)); + } + hi0 = hi1; + } + } + + fn set_compare(instant: Self::Instant) { + let now = Self::now(); + + let max = u32::MAX as u64; + + // Since the timer may or may not overflow based on the requested compare val, we check + // how many ticks are left. + let val = match instant.checked_duration_since(now) { + Some(x) if x.ticks() <= max => instant.duration_since_epoch().ticks() & max, // Will not overflow + _ => 0, // Will overflow or in the past, set the same value as after overflow to not get extra interrupts + }; + + Self::timer() + .alarm0 + .write(|w| unsafe { w.bits(val as u32) }); + } + + fn clear_compare_flag() { + Self::timer().intr.modify(|_, w| w.alarm_0().set_bit()); + } + + fn pend_interrupt() { + cortex_m::peripheral::NVIC::pend(Interrupt::TIMER_IRQ_0); + } + + fn on_interrupt() {} + + fn enable_timer() {} + + fn disable_timer() {} +} + +impl DelayUs for Timer { + type Error = core::convert::Infallible; + + async fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> { + TIMER_QUEUE.delay((us as u64).micros()).await; + Ok(()) + } + + async fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> { + TIMER_QUEUE.delay((ms as u64).millis()).await; + Ok(()) + } +} + +/// Register the Timer interrupt for the monotonic. +#[macro_export] +macro_rules! make_rp2040_monotonic_handler { + () => { + #[no_mangle] + #[allow(non_snake_case)] + unsafe extern "C" fn TIMER_IRQ_0() { + rtic_monotonics::rp2040::Timer::__tq().on_monotonic_interrupt(); + } + }; +} diff --git a/rtic-monotonics/src/systick.rs b/rtic-monotonics/src/systick.rs new file mode 100644 index 0000000..885da92 --- /dev/null +++ b/rtic-monotonics/src/systick.rs @@ -0,0 +1,163 @@ +//! ... + +use super::Monotonic; +pub use super::{TimeoutError, TimerQueue}; +use atomic_polyfill::{AtomicU32, Ordering}; +use core::future::Future; +use cortex_m::peripheral::SYST; +use embedded_hal_async::delay::DelayUs; +pub use fugit::ExtU32; + +// Features should be additive, here systick_100hz gets picked if both +// `systick_100hz` and `systick_10khz` are enabled. + +cfg_if::cfg_if! { + if #[cfg(feature = "systick_100hz")] + { + const TIMER_HZ: u32 = 100; + } else if #[cfg(feature = "systick_10khz")] + { + const TIMER_HZ: u32 = 10_000; + } else { + // Default case is 1 kHz + const TIMER_HZ: u32 = 1_000; + } +} + +/// Systick implementing `rtic_monotonic::Monotonic` which runs at 1 kHz, 100Hz or 10 kHz. +pub struct Systick; + +impl Systick { + /// Start a `Monotonic` based on SysTick. + /// + /// The `sysclk` parameter is the speed at which SysTick runs at. This value should come from + /// the clock generation function of the used HAL. + /// + /// Notice that the actual rate of the timer is a best approximation based on the given + /// `sysclk` and `TIMER_HZ`. + /// + /// Note: Give the return value to `TimerQueue::initialize()` to initialize the timer queue. + pub fn start(mut systick: cortex_m::peripheral::SYST, sysclk: u32) { + // + TIMER_HZ / 2 provides round to nearest instead of round to 0. + // - 1 as the counter range is inclusive [0, reload] + let reload = (sysclk + TIMER_HZ / 2) / TIMER_HZ - 1; + + assert!(reload <= 0x00ff_ffff); + assert!(reload > 0); + + systick.disable_counter(); + systick.set_clock_source(cortex_m::peripheral::syst::SystClkSource::Core); + systick.set_reload(reload); + systick.enable_interrupt(); + systick.enable_counter(); + + SYSTICK_TIMER_QUEUE.initialize(Systick {}); + } + + fn systick() -> SYST { + unsafe { core::mem::transmute::<(), SYST>(()) } + } +} + +static SYSTICK_CNT: AtomicU32 = AtomicU32::new(0); +static SYSTICK_TIMER_QUEUE: TimerQueue = TimerQueue::new(); + +// Forward timerqueue interface +impl Systick { + /// Used to access the underlying timer queue + #[doc(hidden)] + pub fn __tq() -> &'static TimerQueue { + &SYSTICK_TIMER_QUEUE + } + + /// Timeout at a specific time. + pub async fn timeout_at( + instant: ::Instant, + future: F, + ) -> Result { + SYSTICK_TIMER_QUEUE.timeout_at(instant, future).await + } + + /// Timeout after a specific duration. + #[inline] + pub async fn timeout_after( + duration: ::Duration, + future: F, + ) -> Result { + SYSTICK_TIMER_QUEUE.timeout_after(duration, future).await + } + + /// Delay for some duration of time. + #[inline] + pub async fn delay(duration: ::Duration) { + SYSTICK_TIMER_QUEUE.delay(duration).await; + } + + /// Delay to some specific time instant. + pub async fn delay_until(instant: ::Instant) { + SYSTICK_TIMER_QUEUE.delay_until(instant).await; + } +} + +impl Monotonic for Systick { + type Instant = fugit::TimerInstantU32; + type Duration = fugit::TimerDurationU32; + + const ZERO: Self::Instant = Self::Instant::from_ticks(0); + + fn now() -> Self::Instant { + if Self::systick().has_wrapped() { + SYSTICK_CNT.fetch_add(1, Ordering::AcqRel); + } + + Self::Instant::from_ticks(SYSTICK_CNT.load(Ordering::Relaxed)) + } + + fn set_compare(_: Self::Instant) { + // No need to do something here, we get interrupts anyway. + } + + fn clear_compare_flag() { + // NOOP with SysTick interrupt + } + + fn pend_interrupt() { + cortex_m::peripheral::SCB::set_pendst(); + } + + fn on_interrupt() { + if Self::systick().has_wrapped() { + SYSTICK_CNT.fetch_add(1, Ordering::AcqRel); + } + } + + fn enable_timer() {} + + fn disable_timer() {} +} + +impl DelayUs for Systick { + type Error = core::convert::Infallible; + + async fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> { + SYSTICK_TIMER_QUEUE.delay(us.micros()).await; + Ok(()) + } + + async fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> { + SYSTICK_TIMER_QUEUE.delay(ms.millis()).await; + Ok(()) + } +} + +/// Register the Systick interrupt for the monotonic. +#[macro_export] +macro_rules! make_systick_handler { + () => { + #[no_mangle] + #[allow(non_snake_case)] + unsafe extern "C" fn SysTick() { + Systick::__tq().on_monotonic_interrupt(); + } + }; +} diff --git a/rtic-monotonics/src/systick_monotonic.rs b/rtic-monotonics/src/systick_monotonic.rs deleted file mode 100644 index 885da92..0000000 --- a/rtic-monotonics/src/systick_monotonic.rs +++ /dev/null @@ -1,163 +0,0 @@ -//! ... - -use super::Monotonic; -pub use super::{TimeoutError, TimerQueue}; -use atomic_polyfill::{AtomicU32, Ordering}; -use core::future::Future; -use cortex_m::peripheral::SYST; -use embedded_hal_async::delay::DelayUs; -pub use fugit::ExtU32; - -// Features should be additive, here systick_100hz gets picked if both -// `systick_100hz` and `systick_10khz` are enabled. - -cfg_if::cfg_if! { - if #[cfg(feature = "systick_100hz")] - { - const TIMER_HZ: u32 = 100; - } else if #[cfg(feature = "systick_10khz")] - { - const TIMER_HZ: u32 = 10_000; - } else { - // Default case is 1 kHz - const TIMER_HZ: u32 = 1_000; - } -} - -/// Systick implementing `rtic_monotonic::Monotonic` which runs at 1 kHz, 100Hz or 10 kHz. -pub struct Systick; - -impl Systick { - /// Start a `Monotonic` based on SysTick. - /// - /// The `sysclk` parameter is the speed at which SysTick runs at. This value should come from - /// the clock generation function of the used HAL. - /// - /// Notice that the actual rate of the timer is a best approximation based on the given - /// `sysclk` and `TIMER_HZ`. - /// - /// Note: Give the return value to `TimerQueue::initialize()` to initialize the timer queue. - pub fn start(mut systick: cortex_m::peripheral::SYST, sysclk: u32) { - // + TIMER_HZ / 2 provides round to nearest instead of round to 0. - // - 1 as the counter range is inclusive [0, reload] - let reload = (sysclk + TIMER_HZ / 2) / TIMER_HZ - 1; - - assert!(reload <= 0x00ff_ffff); - assert!(reload > 0); - - systick.disable_counter(); - systick.set_clock_source(cortex_m::peripheral::syst::SystClkSource::Core); - systick.set_reload(reload); - systick.enable_interrupt(); - systick.enable_counter(); - - SYSTICK_TIMER_QUEUE.initialize(Systick {}); - } - - fn systick() -> SYST { - unsafe { core::mem::transmute::<(), SYST>(()) } - } -} - -static SYSTICK_CNT: AtomicU32 = AtomicU32::new(0); -static SYSTICK_TIMER_QUEUE: TimerQueue = TimerQueue::new(); - -// Forward timerqueue interface -impl Systick { - /// Used to access the underlying timer queue - #[doc(hidden)] - pub fn __tq() -> &'static TimerQueue { - &SYSTICK_TIMER_QUEUE - } - - /// Timeout at a specific time. - pub async fn timeout_at( - instant: ::Instant, - future: F, - ) -> Result { - SYSTICK_TIMER_QUEUE.timeout_at(instant, future).await - } - - /// Timeout after a specific duration. - #[inline] - pub async fn timeout_after( - duration: ::Duration, - future: F, - ) -> Result { - SYSTICK_TIMER_QUEUE.timeout_after(duration, future).await - } - - /// Delay for some duration of time. - #[inline] - pub async fn delay(duration: ::Duration) { - SYSTICK_TIMER_QUEUE.delay(duration).await; - } - - /// Delay to some specific time instant. - pub async fn delay_until(instant: ::Instant) { - SYSTICK_TIMER_QUEUE.delay_until(instant).await; - } -} - -impl Monotonic for Systick { - type Instant = fugit::TimerInstantU32; - type Duration = fugit::TimerDurationU32; - - const ZERO: Self::Instant = Self::Instant::from_ticks(0); - - fn now() -> Self::Instant { - if Self::systick().has_wrapped() { - SYSTICK_CNT.fetch_add(1, Ordering::AcqRel); - } - - Self::Instant::from_ticks(SYSTICK_CNT.load(Ordering::Relaxed)) - } - - fn set_compare(_: Self::Instant) { - // No need to do something here, we get interrupts anyway. - } - - fn clear_compare_flag() { - // NOOP with SysTick interrupt - } - - fn pend_interrupt() { - cortex_m::peripheral::SCB::set_pendst(); - } - - fn on_interrupt() { - if Self::systick().has_wrapped() { - SYSTICK_CNT.fetch_add(1, Ordering::AcqRel); - } - } - - fn enable_timer() {} - - fn disable_timer() {} -} - -impl DelayUs for Systick { - type Error = core::convert::Infallible; - - async fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> { - SYSTICK_TIMER_QUEUE.delay(us.micros()).await; - Ok(()) - } - - async fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> { - SYSTICK_TIMER_QUEUE.delay(ms.millis()).await; - Ok(()) - } -} - -/// Register the Systick interrupt for the monotonic. -#[macro_export] -macro_rules! make_systick_handler { - () => { - #[no_mangle] - #[allow(non_snake_case)] - unsafe extern "C" fn SysTick() { - Systick::__tq().on_monotonic_interrupt(); - } - }; -} -- cgit v1.2.3