mirror of
https://github.com/rtic-rs/rtic.git
synced 2025-12-16 21:05:35 +01:00
Add Monotonic for i.MX RT chip family
This commit is contained in:
Finomnis
Emil Fresk
parent
a7f81262f6
commit
2fd3b3c404
13 changed files with 1251 additions and 1 deletions
|
|
@ -7,6 +7,10 @@ For each category, *Added*, *Changed*, *Fixed* add new entries at the top!
|
|||
|
||||
## Unreleased
|
||||
|
||||
### Added
|
||||
|
||||
- i.MX RT support
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix STM32 rollover race condition
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "rtic-monotonics"
|
||||
version = "1.2.0"
|
||||
version = "1.2.1"
|
||||
|
||||
edition = "2021"
|
||||
authors = [
|
||||
|
|
@ -45,6 +45,9 @@ nrf9160-pac = { version = "0.12.2", optional = true }
|
|||
# STM32
|
||||
stm32-metapac = { version = "14.0.0", optional = true }
|
||||
|
||||
# i.MX RT
|
||||
imxrt-ral = { version = "0.5.3", optional = true }
|
||||
|
||||
[build-dependencies]
|
||||
proc-macro2 = { version = "1.0.36", optional = true }
|
||||
quote = { version = "1.0.15", optional = true }
|
||||
|
|
@ -74,6 +77,12 @@ nrf5340-app = ["dep:cortex-m", "dep:nrf5340-app-pac", "dep:critical-section"]
|
|||
nrf5340-net = ["dep:cortex-m", "dep:nrf5340-net-pac", "dep:critical-section"]
|
||||
nrf9160 = ["dep:cortex-m", "dep:nrf9160-pac", "dep:critical-section"]
|
||||
|
||||
# i.MX RT Timers
|
||||
# Use as `features = ["imxrt_gpt1"]`
|
||||
imxrt = ["dep:cortex-m", "dep:imxrt-ral"]
|
||||
imxrt_gpt1 = ["imxrt"]
|
||||
imxrt_gpt2 = ["imxrt"]
|
||||
|
||||
# STM32 timers
|
||||
# Use as `features = ["stm32g081kb", "stm32_tim15"]`
|
||||
stm32_tim2 = []
|
||||
|
|
|
|||
300
rtic-monotonics/src/imxrt.rs
Normal file
300
rtic-monotonics/src/imxrt.rs
Normal file
|
|
@ -0,0 +1,300 @@
|
|||
//! [`Monotonic`] impl for the i.MX RT.
|
||||
//!
|
||||
//! # Example
|
||||
//!
|
||||
//! ```
|
||||
//! use rtic_monotonics::imxrt::*;
|
||||
//! use rtic_monotonics::imxrt::Gpt1 as Mono;
|
||||
//!
|
||||
//! fn init() {
|
||||
//! // Obtain ownership of the timer register block
|
||||
//! let gpt1 = unsafe { imxrt_ral::gpt::GPT1::instance() };
|
||||
//!
|
||||
//! // Configure the timer clock source and determine its tick rate
|
||||
//! let timer_tickrate_hz = 1_000_000;
|
||||
//!
|
||||
//! // Generate timer token to ensure correct timer interrupt handler is used
|
||||
//! let token = rtic_monotonics::create_imxrt_gpt1_token!();
|
||||
//!
|
||||
//! // Start the monotonic
|
||||
//! Mono::start(timer_tickrate_hz, gpt1, token);
|
||||
//! }
|
||||
//!
|
||||
//! async fn usage() {
|
||||
//! loop {
|
||||
//! // Use the monotonic
|
||||
//! let timestamp = Mono::now().ticks();
|
||||
//! Mono::delay(100.millis()).await;
|
||||
//! }
|
||||
//! }
|
||||
//! ```
|
||||
|
||||
use crate::{Monotonic, TimeoutError, TimerQueue};
|
||||
use atomic_polyfill::{compiler_fence, AtomicU32, Ordering};
|
||||
pub use fugit::{self, ExtU64};
|
||||
|
||||
use imxrt_ral as ral;
|
||||
|
||||
const TIMER_HZ: u32 = 1_000_000;
|
||||
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! __internal_create_imxrt_timer_interrupt {
|
||||
($mono_timer:ident, $timer:ident, $timer_token:ident) => {{
|
||||
#[no_mangle]
|
||||
#[allow(non_snake_case)]
|
||||
unsafe extern "C" fn $timer() {
|
||||
$crate::imxrt::$mono_timer::__tq().on_monotonic_interrupt();
|
||||
}
|
||||
|
||||
pub struct $timer_token;
|
||||
|
||||
unsafe impl $crate::InterruptToken<$crate::imxrt::$mono_timer> for $timer_token {}
|
||||
|
||||
$timer_token
|
||||
}};
|
||||
}
|
||||
|
||||
/// Register GPT1 interrupt for the monotonic.
|
||||
#[cfg(feature = "imxrt_gpt1")]
|
||||
#[macro_export]
|
||||
macro_rules! create_imxrt_gpt1_token {
|
||||
() => {{
|
||||
$crate::__internal_create_imxrt_timer_interrupt!(Gpt1, GPT1, Gpt1Token)
|
||||
}};
|
||||
}
|
||||
|
||||
/// Register GPT2 interrupt for the monotonic.
|
||||
#[cfg(feature = "imxrt_gpt2")]
|
||||
#[macro_export]
|
||||
macro_rules! create_imxrt_gpt2_token {
|
||||
() => {{
|
||||
$crate::__internal_create_imxrt_timer_interrupt!(Gpt2, GPT2, Gpt2Token)
|
||||
}};
|
||||
}
|
||||
|
||||
// Credits to the `time-driver` of `embassy-stm32`.
|
||||
//
|
||||
// Clock timekeeping works with something we call "periods", which are time intervals
|
||||
// of 2^31 ticks. The Clock counter value is 32 bits, so one "overflow cycle" is 2 periods.
|
||||
//
|
||||
// A `period` count is maintained in parallel to the Timer hardware `counter`, like this:
|
||||
// - `period` and `counter` start at 0
|
||||
// - `period` is incremented on overflow (at counter value 0)
|
||||
// - `period` is incremented "midway" between overflows (at counter value 0x8000_0000)
|
||||
//
|
||||
// Therefore, when `period` is even, counter is in 0..0x7FFF_FFFF. When odd, counter is in 0x8000_0000..0xFFFF_FFFF
|
||||
// This allows for now() to return the correct value even if it races an overflow.
|
||||
//
|
||||
// To get `now()`, `period` is read first, then `counter` is read. If the counter value matches
|
||||
// the expected range for the `period` parity, we're done. If it doesn't, this means that
|
||||
// a new period start has raced us between reading `period` and `counter`, so we assume the `counter` value
|
||||
// corresponds to the next period.
|
||||
//
|
||||
// `period` is a 32bit integer, so it overflows on 2^32 * 2^31 / 1_000_000 seconds of uptime, which is 292471 years.
|
||||
fn calc_now(period: u32, counter: u32) -> u64 {
|
||||
(u64::from(period) << 31) + u64::from(counter ^ ((period & 1) << 31))
|
||||
}
|
||||
|
||||
macro_rules! make_timer {
|
||||
($mono_name:ident, $timer:ident, $period:ident, $tq:ident$(, doc: ($($doc:tt)*))?) => {
|
||||
/// Monotonic timer queue implementation.
|
||||
$(
|
||||
#[cfg_attr(docsrs, doc(cfg($($doc)*)))]
|
||||
)?
|
||||
|
||||
pub struct $mono_name;
|
||||
|
||||
use ral::gpt::$timer;
|
||||
|
||||
/// Number of 2^31 periods elapsed since boot.
|
||||
static $period: AtomicU32 = AtomicU32::new(0);
|
||||
static $tq: TimerQueue<$mono_name> = TimerQueue::new();
|
||||
|
||||
impl $mono_name {
|
||||
/// Starts the monotonic timer.
|
||||
/// - `tick_freq_hz`: The tick frequency of the given timer.
|
||||
/// - `gpt`: The GPT timer register block instance.
|
||||
/// - `_interrupt_token`: Required for correct timer interrupt handling.
|
||||
/// This method must be called only once.
|
||||
pub fn start(tick_freq_hz: u32, gpt: $timer, _interrupt_token: impl crate::InterruptToken<Self>) {
|
||||
// Find a prescaler that creates our desired tick frequency
|
||||
let previous_prescaler = ral::read_reg!(ral::gpt, gpt, PR, PRESCALER) + 1;
|
||||
let previous_clock_freq = tick_freq_hz * previous_prescaler;
|
||||
assert!((previous_clock_freq % TIMER_HZ) == 0,
|
||||
"Unable to find a fitting prescaler value!\n Input: {}/{}\n Desired: {}",
|
||||
previous_clock_freq, previous_prescaler, TIMER_HZ);
|
||||
let prescaler = previous_clock_freq / TIMER_HZ;
|
||||
assert!(prescaler > 0);
|
||||
assert!(prescaler <= 4096);
|
||||
|
||||
// Disable the timer.
|
||||
ral::modify_reg!(ral::gpt, gpt, CR, EN: 0);
|
||||
// Clear all status registers.
|
||||
ral::write_reg!(ral::gpt, gpt, SR, 0b11_1111);
|
||||
|
||||
// Base configuration
|
||||
ral::modify_reg!(ral::gpt, gpt, CR,
|
||||
ENMOD: 1, // Clear timer state
|
||||
FRR: 1, // Free-Run mode
|
||||
);
|
||||
|
||||
// Reset period
|
||||
$period.store(0, Ordering::Relaxed);
|
||||
|
||||
// Prescaler
|
||||
ral::modify_reg!(ral::gpt, gpt, PR,
|
||||
PRESCALER: (prescaler - 1), // Scale to our desired clock rate
|
||||
);
|
||||
|
||||
// Enable interrupts
|
||||
ral::write_reg!(ral::gpt, gpt, IR,
|
||||
ROVIE: 1, // Rollover interrupt
|
||||
OF1IE: 1, // Timer compare 1 interrupt (for half-periods)
|
||||
OF2IE: 1, // Timer compare 2 interrupt (for dynamic wakeup)
|
||||
);
|
||||
|
||||
// Configure half-period interrupt
|
||||
ral::write_reg!(ral::gpt, gpt, OCR[0], 0x8000_0000);
|
||||
|
||||
// Dynamic interrupt register; for now initialize to zero
|
||||
// so it gets combined with rollover interrupt
|
||||
ral::write_reg!(ral::gpt, gpt, OCR[1], 0x0000_0000);
|
||||
|
||||
// Enable the timer
|
||||
ral::modify_reg!(ral::gpt, gpt, CR, EN: 1);
|
||||
ral::modify_reg!(ral::gpt, gpt, CR,
|
||||
ENMOD: 0, // Keep state when disabled
|
||||
);
|
||||
|
||||
$tq.initialize(Self {});
|
||||
|
||||
// SAFETY: We take full ownership of the peripheral and interrupt vector,
|
||||
// plus we are not using any external shared resources so we won't impact
|
||||
// basepri/source masking based critical sections.
|
||||
unsafe {
|
||||
crate::set_monotonic_prio(ral::NVIC_PRIO_BITS, ral::Interrupt::$timer);
|
||||
cortex_m::peripheral::NVIC::unmask(ral::Interrupt::$timer);
|
||||
}
|
||||
}
|
||||
|
||||
/// Used to access the underlying timer queue
|
||||
#[doc(hidden)]
|
||||
pub fn __tq() -> &'static TimerQueue<$mono_name> {
|
||||
&$tq
|
||||
}
|
||||
|
||||
/// Delay for some duration of time.
|
||||
#[inline]
|
||||
pub async fn delay(duration: <Self as Monotonic>::Duration) {
|
||||
$tq.delay(duration).await;
|
||||
}
|
||||
|
||||
/// Timeout at a specific time.
|
||||
pub async fn timeout_at<F: core::future::Future>(
|
||||
instant: <Self as rtic_time::Monotonic>::Instant,
|
||||
future: F,
|
||||
) -> Result<F::Output, TimeoutError> {
|
||||
$tq.timeout_at(instant, future).await
|
||||
}
|
||||
|
||||
/// Timeout after a specific duration.
|
||||
#[inline]
|
||||
pub async fn timeout_after<F: core::future::Future>(
|
||||
duration: <Self as Monotonic>::Duration,
|
||||
future: F,
|
||||
) -> Result<F::Output, TimeoutError> {
|
||||
$tq.timeout_after(duration, future).await
|
||||
}
|
||||
|
||||
/// Delay to some specific time instant.
|
||||
#[inline]
|
||||
pub async fn delay_until(instant: <Self as Monotonic>::Instant) {
|
||||
$tq.delay_until(instant).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "embedded-hal-async")]
|
||||
impl embedded_hal_async::delay::DelayUs for $mono_name {
|
||||
#[inline]
|
||||
async fn delay_us(&mut self, us: u32) {
|
||||
Self::delay((us as u64).micros()).await;
|
||||
}
|
||||
|
||||
#[inline]
|
||||
async fn delay_ms(&mut self, ms: u32) {
|
||||
Self::delay((ms as u64).millis()).await;
|
||||
}
|
||||
}
|
||||
|
||||
impl embedded_hal::delay::DelayUs for $mono_name {
|
||||
fn delay_us(&mut self, us: u32) {
|
||||
let done = Self::now() + (us as u64).micros();
|
||||
while Self::now() < done {}
|
||||
}
|
||||
}
|
||||
|
||||
impl Monotonic for $mono_name {
|
||||
type Instant = fugit::TimerInstantU64<TIMER_HZ>;
|
||||
type Duration = fugit::TimerDurationU64<TIMER_HZ>;
|
||||
|
||||
const ZERO: Self::Instant = Self::Instant::from_ticks(0);
|
||||
|
||||
fn now() -> Self::Instant {
|
||||
let gpt = unsafe{ $timer::instance() };
|
||||
|
||||
// Important: period **must** be read first.
|
||||
let period = $period.load(Ordering::Relaxed);
|
||||
compiler_fence(Ordering::Acquire);
|
||||
let counter = ral::read_reg!(ral::gpt, gpt, CNT);
|
||||
|
||||
Self::Instant::from_ticks(calc_now(period, counter))
|
||||
}
|
||||
|
||||
fn set_compare(instant: Self::Instant) {
|
||||
let gpt = unsafe{ $timer::instance() };
|
||||
|
||||
// Set the timer regardless of whether it is multiple periods in the future,
|
||||
// or even already in the past.
|
||||
// The worst thing that can happen is a spurious wakeup, and with a timer
|
||||
// period of half an hour, this is hardly a problem.
|
||||
|
||||
let ticks = instant.duration_since_epoch().ticks();
|
||||
let ticks_wrapped = ticks as u32;
|
||||
|
||||
ral::write_reg!(ral::gpt, gpt, OCR[1], ticks_wrapped);
|
||||
}
|
||||
|
||||
fn clear_compare_flag() {
|
||||
let gpt = unsafe{ $timer::instance() };
|
||||
ral::write_reg!(ral::gpt, gpt, SR, OF2: 1);
|
||||
}
|
||||
|
||||
fn pend_interrupt() {
|
||||
cortex_m::peripheral::NVIC::pend(ral::Interrupt::$timer);
|
||||
}
|
||||
|
||||
fn on_interrupt() {
|
||||
let gpt = unsafe{ $timer::instance() };
|
||||
|
||||
let (rollover, half_rollover) = ral::read_reg!(ral::gpt, gpt, SR, ROV, OF1);
|
||||
|
||||
if rollover != 0 {
|
||||
$period.fetch_add(1, Ordering::Relaxed);
|
||||
ral::write_reg!(ral::gpt, gpt, SR, ROV: 1);
|
||||
}
|
||||
|
||||
if half_rollover != 0 {
|
||||
$period.fetch_add(1, Ordering::Relaxed);
|
||||
ral::write_reg!(ral::gpt, gpt, SR, OF1: 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(feature = "imxrt_gpt1")]
|
||||
make_timer!(Gpt1, GPT1, GPT1_HALFPERIODS, GPT1_TQ);
|
||||
|
||||
#[cfg(feature = "imxrt_gpt2")]
|
||||
make_timer!(Gpt2, GPT2, GPT2_HALFPERIODS, GPT2_TQ);
|
||||
|
|
@ -33,6 +33,9 @@ pub mod systick;
|
|||
#[cfg(feature = "rp2040")]
|
||||
pub mod rp2040;
|
||||
|
||||
#[cfg(feature = "imxrt")]
|
||||
pub mod imxrt;
|
||||
|
||||
#[cfg(any(
|
||||
feature = "nrf52810",
|
||||
feature = "nrf52811",
|
||||
|
|
@ -64,6 +67,7 @@ pub(crate) const fn cortex_logical2hw(logical: u8, nvic_prio_bits: u8) -> u8 {
|
|||
feature = "nrf5340-app",
|
||||
feature = "nrf5340-net",
|
||||
feature = "nrf9160",
|
||||
feature = "imxrt",
|
||||
stm32,
|
||||
))]
|
||||
pub(crate) unsafe fn set_monotonic_prio(
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue