stm32f4xx_hal/timer/
hal_02.rs

1//! Delay implementation based on general-purpose 32 bit timers and System timer (SysTick).
2//!
3//! TIM2 and TIM5 are a general purpose 32-bit auto-reload up/downcounter with
4//! a 16-bit prescaler.
5
6use embedded_hal_02::{
7    blocking::delay::{DelayMs, DelayUs},
8    timer::{Cancel, CountDown, Periodic},
9};
10use fugit::{ExtU32Ceil, HertzU32 as Hertz, TimerDurationU32};
11use void::Void;
12
13use super::{
14    CPin, Counter, CounterHz, Delay, ErasedChannel, Error, Instance, PwmChannel, SysCounter,
15    SysCounterHz, SysDelay, WithPwm,
16};
17
18impl DelayUs<u32> for SysDelay {
19    #[inline]
20    fn delay_us(&mut self, us: u32) {
21        self.delay(us.micros_at_least())
22    }
23}
24
25impl DelayMs<u32> for SysDelay {
26    #[inline]
27    fn delay_ms(&mut self, ms: u32) {
28        self.delay(ms.millis_at_least());
29    }
30}
31
32impl DelayUs<u16> for SysDelay {
33    #[inline]
34    fn delay_us(&mut self, us: u16) {
35        self.delay_us(us as u32)
36    }
37}
38
39impl DelayMs<u16> for SysDelay {
40    #[inline]
41    fn delay_ms(&mut self, ms: u16) {
42        self.delay_ms(ms as u32);
43    }
44}
45
46impl DelayUs<u8> for SysDelay {
47    #[inline]
48    fn delay_us(&mut self, us: u8) {
49        self.delay_us(us as u32)
50    }
51}
52
53impl DelayMs<u8> for SysDelay {
54    #[inline]
55    fn delay_ms(&mut self, ms: u8) {
56        self.delay_ms(ms as u32);
57    }
58}
59
60impl<TIM> Periodic for CounterHz<TIM> {}
61impl Periodic for SysCounterHz {}
62impl<const FREQ: u32> Periodic for SysCounter<FREQ> {}
63
64impl CountDown for SysCounterHz {
65    type Time = Hertz;
66
67    fn start<T>(&mut self, timeout: T)
68    where
69        T: Into<Hertz>,
70    {
71        self.start(timeout.into()).unwrap()
72    }
73
74    fn wait(&mut self) -> nb::Result<(), Void> {
75        match self.wait() {
76            Err(nb::Error::WouldBlock) => Err(nb::Error::WouldBlock),
77            _ => Ok(()),
78        }
79    }
80}
81
82impl Cancel for SysCounterHz {
83    type Error = Error;
84
85    fn cancel(&mut self) -> Result<(), Self::Error> {
86        self.cancel()
87    }
88}
89
90impl<TIM: Instance> CountDown for CounterHz<TIM> {
91    type Time = Hertz;
92
93    fn start<T>(&mut self, timeout: T)
94    where
95        T: Into<Hertz>,
96    {
97        self.start(timeout.into()).unwrap()
98    }
99
100    fn wait(&mut self) -> nb::Result<(), Void> {
101        match self.wait() {
102            Err(nb::Error::WouldBlock) => Err(nb::Error::WouldBlock),
103            _ => Ok(()),
104        }
105    }
106}
107
108impl<TIM: Instance> Cancel for CounterHz<TIM> {
109    type Error = Error;
110
111    fn cancel(&mut self) -> Result<(), Self::Error> {
112        self.cancel()
113    }
114}
115
116impl<const FREQ: u32> CountDown for SysCounter<FREQ> {
117    type Time = TimerDurationU32<FREQ>;
118
119    fn start<T>(&mut self, timeout: T)
120    where
121        T: Into<Self::Time>,
122    {
123        self.start(timeout.into()).unwrap()
124    }
125
126    fn wait(&mut self) -> nb::Result<(), Void> {
127        match self.wait() {
128            Err(nb::Error::WouldBlock) => Err(nb::Error::WouldBlock),
129            _ => Ok(()),
130        }
131    }
132}
133
134impl<const FREQ: u32> Cancel for SysCounter<FREQ> {
135    type Error = Error;
136
137    fn cancel(&mut self) -> Result<(), Self::Error> {
138        self.cancel()
139    }
140}
141
142impl<TIM: Instance + WithPwm + CPin<C>, const C: u8, const COMP: bool, Otype>
143    embedded_hal_02::PwmPin for PwmChannel<TIM, C, COMP, Otype>
144{
145    type Duty = u16;
146
147    fn disable(&mut self) {
148        self.disable()
149    }
150    fn enable(&mut self) {
151        self.enable()
152    }
153    fn get_duty(&self) -> Self::Duty {
154        self.get_duty()
155    }
156    fn get_max_duty(&self) -> Self::Duty {
157        self.get_max_duty()
158    }
159    fn set_duty(&mut self, duty: Self::Duty) {
160        self.set_duty(duty)
161    }
162}
163
164impl<TIM: Instance + WithPwm> embedded_hal_02::PwmPin for ErasedChannel<TIM> {
165    type Duty = u16;
166
167    fn disable(&mut self) {
168        self.disable()
169    }
170    fn enable(&mut self) {
171        self.enable()
172    }
173    fn get_duty(&self) -> Self::Duty {
174        self.get_duty()
175    }
176    fn get_max_duty(&self) -> Self::Duty {
177        self.get_max_duty()
178    }
179    fn set_duty(&mut self, duty: Self::Duty) {
180        self.set_duty(duty)
181    }
182}
183
184impl<TIM: Instance, const FREQ: u32> DelayUs<u32> for Delay<TIM, FREQ> {
185    /// Sleep for `us` microseconds
186    fn delay_us(&mut self, us: u32) {
187        self.delay(us.micros_at_least())
188    }
189}
190
191impl<TIM: Instance, const FREQ: u32> DelayMs<u32> for Delay<TIM, FREQ> {
192    /// Sleep for `ms` milliseconds
193    fn delay_ms(&mut self, ms: u32) {
194        self.delay(ms.millis_at_least())
195    }
196}
197
198impl<TIM: Instance, const FREQ: u32> DelayUs<u16> for Delay<TIM, FREQ> {
199    /// Sleep for `us` microseconds
200    fn delay_us(&mut self, us: u16) {
201        self.delay((us as u32).micros_at_least())
202    }
203}
204impl<TIM: Instance, const FREQ: u32> DelayMs<u16> for Delay<TIM, FREQ> {
205    /// Sleep for `ms` milliseconds
206    fn delay_ms(&mut self, ms: u16) {
207        self.delay((ms as u32).millis_at_least())
208    }
209}
210
211impl<TIM: Instance, const FREQ: u32> DelayUs<u8> for Delay<TIM, FREQ> {
212    /// Sleep for `us` microseconds
213    fn delay_us(&mut self, us: u8) {
214        self.delay((us as u32).micros_at_least())
215    }
216}
217impl<TIM: Instance, const FREQ: u32> DelayMs<u8> for Delay<TIM, FREQ> {
218    /// Sleep for `ms` milliseconds
219    fn delay_ms(&mut self, ms: u8) {
220        self.delay((ms as u32).millis_at_least())
221    }
222}
223
224impl<TIM: Instance, const FREQ: u32> Periodic for Counter<TIM, FREQ> {}
225
226impl<TIM: Instance, const FREQ: u32> CountDown for Counter<TIM, FREQ> {
227    type Time = TimerDurationU32<FREQ>;
228
229    fn start<T>(&mut self, timeout: T)
230    where
231        T: Into<Self::Time>,
232    {
233        self.start(timeout.into()).unwrap()
234    }
235
236    fn wait(&mut self) -> nb::Result<(), Void> {
237        match self.wait() {
238            Err(nb::Error::WouldBlock) => Err(nb::Error::WouldBlock),
239            _ => Ok(()),
240        }
241    }
242}
243
244impl<TIM: Instance, const FREQ: u32> Cancel for Counter<TIM, FREQ> {
245    type Error = Error;
246
247    fn cancel(&mut self) -> Result<(), Self::Error> {
248        self.cancel()
249    }
250}
stm32f4xx_hal/timer/hal_02.rs

stm32f4xx_hal/timer/
hal_02.rs
