asm_delay_embedded_time/
lib.rs

1//! no_std implementation of DelayMs and DelayUs for cortex-m
2
3#![deny(missing_docs)]
4#![no_std]
5
6pub use embedded_time;
7use embedded_time::rate::*;
8use cortex_m::asm::delay;
9use embedded_hal::blocking::delay::DelayMs;
10use embedded_hal::blocking::delay::DelayUs;
11
12/// asm::delay based Timer
13pub struct AsmDelay {
14    freq_base_ms: u32,
15    freq_base_us: u32,
16}
17
18impl AsmDelay {
19    /// Consturct new delay timer of CPU frequency (Hertz)
20    pub fn new<F>(freq: F) -> Self
21    where
22        F: Into<Hertz<u32>>,
23    {
24        let freq_hz = freq.into().0;
25        AsmDelay {
26            freq_base_ms: (freq_hz / 1_000) / 2,
27            freq_base_us: (freq_hz / 1_000_000) / 2,
28        }
29    }
30}
31
32impl<U> DelayMs<U> for AsmDelay
33where
34    U: Into<u32>,
35{
36    fn delay_ms(&mut self, ms: U) {
37        delay(self.freq_base_ms * ms.into())
38    }
39}
40impl<U> DelayUs<U> for AsmDelay
41where
42    U: Into<u32>,
43{
44    fn delay_us(&mut self, us: U) {
45        delay(self.freq_base_us * us.into())
46    }
47}
48
49/// Convert cycles back to time
50pub struct CyclesToTime {
51    freq_base_ms: f32,
52    freq_base_us: f32,
53}
54
55impl CyclesToTime {
56    /// Consturct new cycles to time converter of CPU frequency (Hertz)
57    pub fn new<F>(freq: F) -> Self
58    where
59        F: Into<Hertz<u32>>,
60    {
61        let freq_hz = freq.into().0;
62        CyclesToTime {
63            freq_base_ms: (freq_hz / 1_000) as f32,
64            freq_base_us: (freq_hz / 1_000_000) as f32,
65        }
66    }
67
68    /// Converts cycles to ms
69    pub fn to_ms<U>(&self, cycles: U) -> f32
70    where
71        U: Into<u32>,
72    {
73        (cycles.into() as f32) / self.freq_base_ms
74    }
75
76    /// Converts cycles to us
77    pub fn to_us<U>(&self, cycles: U) -> f32
78    where
79        U: Into<u32>,
80    {
81        (cycles.into() as f32) / self.freq_base_us
82    }
83}