embassy_stm32/hrtim/
mod.rs

1//! High Resolution Timer (HRTIM)
2
3mod traits;
4
5use core::marker::PhantomData;
6
7use embassy_hal_internal::{into_ref, PeripheralRef};
8pub use traits::Instance;
9
10use crate::gpio::{AfType, AnyPin, OutputType, Speed};
11use crate::time::Hertz;
12use crate::{rcc, Peripheral};
13
14/// HRTIM burst controller instance.
15pub struct BurstController<T: Instance> {
16    phantom: PhantomData<T>,
17}
18
19/// HRTIM master instance.
20pub struct Master<T: Instance> {
21    phantom: PhantomData<T>,
22}
23
24/// HRTIM channel A instance.
25pub struct ChA<T: Instance> {
26    phantom: PhantomData<T>,
27}
28
29/// HRTIM channel B instance.
30pub struct ChB<T: Instance> {
31    phantom: PhantomData<T>,
32}
33
34/// HRTIM channel C instance.
35pub struct ChC<T: Instance> {
36    phantom: PhantomData<T>,
37}
38
39/// HRTIM channel D instance.
40pub struct ChD<T: Instance> {
41    phantom: PhantomData<T>,
42}
43
44/// HRTIM channel E instance.
45pub struct ChE<T: Instance> {
46    phantom: PhantomData<T>,
47}
48
49/// HRTIM channel F instance.
50#[cfg(hrtim_v2)]
51pub struct ChF<T: Instance> {
52    phantom: PhantomData<T>,
53}
54
55trait SealedAdvancedChannel<T: Instance> {
56    fn raw() -> usize;
57}
58
59/// Advanced channel instance trait.
60#[allow(private_bounds)]
61pub trait AdvancedChannel<T: Instance>: SealedAdvancedChannel<T> {}
62
63/// HRTIM PWM pin.
64pub struct PwmPin<'d, T, C> {
65    _pin: PeripheralRef<'d, AnyPin>,
66    phantom: PhantomData<(T, C)>,
67}
68
69/// HRTIM complementary PWM pin.
70pub struct ComplementaryPwmPin<'d, T, C> {
71    _pin: PeripheralRef<'d, AnyPin>,
72    phantom: PhantomData<(T, C)>,
73}
74
75macro_rules! advanced_channel_impl {
76    ($new_chx:ident, $channel:tt, $ch_num:expr, $pin_trait:ident, $complementary_pin_trait:ident) => {
77        impl<'d, T: Instance> PwmPin<'d, T, $channel<T>> {
78            #[doc = concat!("Create a new ", stringify!($channel), " PWM pin instance.")]
79            pub fn $new_chx(pin: impl Peripheral<P = impl $pin_trait<T>> + 'd) -> Self {
80                into_ref!(pin);
81                critical_section::with(|_| {
82                    pin.set_low();
83                    pin.set_as_af(
84                        pin.af_num(),
85                        AfType::output(OutputType::PushPull, Speed::VeryHigh),
86                    );
87                });
88                PwmPin {
89                    _pin: pin.map_into(),
90                    phantom: PhantomData,
91                }
92            }
93        }
94
95        impl<'d, T: Instance> ComplementaryPwmPin<'d, T, $channel<T>> {
96            #[doc = concat!("Create a new ", stringify!($channel), " complementary PWM pin instance.")]
97            pub fn $new_chx(pin: impl Peripheral<P = impl $complementary_pin_trait<T>> + 'd) -> Self {
98                into_ref!(pin);
99                critical_section::with(|_| {
100                    pin.set_low();
101                    pin.set_as_af(
102                        pin.af_num(),
103                        AfType::output(OutputType::PushPull, Speed::VeryHigh),
104                    );
105                });
106                ComplementaryPwmPin {
107                    _pin: pin.map_into(),
108                    phantom: PhantomData,
109                }
110            }
111        }
112
113        impl<T: Instance> SealedAdvancedChannel<T> for $channel<T> {
114            fn raw() -> usize {
115                $ch_num
116            }
117        }
118        impl<T: Instance> AdvancedChannel<T> for $channel<T> {}
119    };
120}
121
122advanced_channel_impl!(new_cha, ChA, 0, ChannelAPin, ChannelAComplementaryPin);
123advanced_channel_impl!(new_chb, ChB, 1, ChannelBPin, ChannelBComplementaryPin);
124advanced_channel_impl!(new_chc, ChC, 2, ChannelCPin, ChannelCComplementaryPin);
125advanced_channel_impl!(new_chd, ChD, 3, ChannelDPin, ChannelDComplementaryPin);
126advanced_channel_impl!(new_che, ChE, 4, ChannelEPin, ChannelEComplementaryPin);
127#[cfg(hrtim_v2)]
128advanced_channel_impl!(new_chf, ChF, 5, ChannelFPin, ChannelFComplementaryPin);
129
130/// Struct used to divide a high resolution timer into multiple channels
131pub struct AdvancedPwm<'d, T: Instance> {
132    _inner: PeripheralRef<'d, T>,
133    /// Master instance.
134    pub master: Master<T>,
135    /// Burst controller.
136    pub burst_controller: BurstController<T>,
137    /// Channel A.
138    pub ch_a: ChA<T>,
139    /// Channel B.
140    pub ch_b: ChB<T>,
141    /// Channel C.
142    pub ch_c: ChC<T>,
143    /// Channel D.
144    pub ch_d: ChD<T>,
145    /// Channel E.
146    pub ch_e: ChE<T>,
147    /// Channel F.
148    #[cfg(hrtim_v2)]
149    pub ch_f: ChF<T>,
150}
151
152impl<'d, T: Instance> AdvancedPwm<'d, T> {
153    /// Create a new HRTIM driver.
154    ///
155    /// This splits the HRTIM into its constituent parts, which you can then use individually.
156    pub fn new(
157        tim: impl Peripheral<P = T> + 'd,
158        _cha: Option<PwmPin<'d, T, ChA<T>>>,
159        _chan: Option<ComplementaryPwmPin<'d, T, ChA<T>>>,
160        _chb: Option<PwmPin<'d, T, ChB<T>>>,
161        _chbn: Option<ComplementaryPwmPin<'d, T, ChB<T>>>,
162        _chc: Option<PwmPin<'d, T, ChC<T>>>,
163        _chcn: Option<ComplementaryPwmPin<'d, T, ChC<T>>>,
164        _chd: Option<PwmPin<'d, T, ChD<T>>>,
165        _chdn: Option<ComplementaryPwmPin<'d, T, ChD<T>>>,
166        _che: Option<PwmPin<'d, T, ChE<T>>>,
167        _chen: Option<ComplementaryPwmPin<'d, T, ChE<T>>>,
168        #[cfg(hrtim_v2)] _chf: Option<PwmPin<'d, T, ChF<T>>>,
169        #[cfg(hrtim_v2)] _chfn: Option<ComplementaryPwmPin<'d, T, ChF<T>>>,
170    ) -> Self {
171        Self::new_inner(tim)
172    }
173
174    fn new_inner(tim: impl Peripheral<P = T> + 'd) -> Self {
175        into_ref!(tim);
176
177        rcc::enable_and_reset::<T>();
178
179        #[cfg(stm32f334)]
180        if crate::pac::RCC.cfgr3().read().hrtim1sw() == crate::pac::rcc::vals::Timsw::PLL1_P {
181            // Enable and and stabilize the DLL
182            T::regs().dllcr().modify(|w| {
183                w.set_cal(true);
184            });
185
186            trace!("hrtim: wait for dll calibration");
187            while !T::regs().isr().read().dllrdy() {}
188
189            trace!("hrtim: dll calibration complete");
190
191            // Enable periodic calibration
192            // Cal must be disabled before we can enable it
193            T::regs().dllcr().modify(|w| {
194                w.set_cal(false);
195            });
196
197            T::regs().dllcr().modify(|w| {
198                w.set_calen(true);
199                w.set_calrte(11);
200            });
201        }
202
203        Self {
204            _inner: tim,
205            master: Master { phantom: PhantomData },
206            burst_controller: BurstController { phantom: PhantomData },
207            ch_a: ChA { phantom: PhantomData },
208            ch_b: ChB { phantom: PhantomData },
209            ch_c: ChC { phantom: PhantomData },
210            ch_d: ChD { phantom: PhantomData },
211            ch_e: ChE { phantom: PhantomData },
212            #[cfg(hrtim_v2)]
213            ch_f: ChF { phantom: PhantomData },
214        }
215    }
216}
217
218/// Fixed-frequency bridge converter driver.
219///
220/// Our implementation of the bridge converter uses a single channel and three compare registers,
221/// allowing implementation of a synchronous buck or boost converter in continuous or discontinuous
222/// conduction mode.
223///
224/// It is important to remember that in synchronous topologies, energy can flow in reverse during
225/// light loading conditions, and that the low-side switch must be active for a short time to drive
226/// a bootstrapped high-side switch.
227pub struct BridgeConverter<T: Instance, C: AdvancedChannel<T>> {
228    timer: PhantomData<T>,
229    channel: PhantomData<C>,
230    dead_time: u16,
231    primary_duty: u16,
232    min_secondary_duty: u16,
233    max_secondary_duty: u16,
234}
235
236impl<T: Instance, C: AdvancedChannel<T>> BridgeConverter<T, C> {
237    /// Create a new HRTIM bridge converter driver.
238    pub fn new(_channel: C, frequency: Hertz) -> Self {
239        T::set_channel_frequency(C::raw(), frequency);
240
241        // Always enable preload
242        T::regs().tim(C::raw()).cr().modify(|w| {
243            w.set_preen(true);
244            w.set_repu(true);
245            w.set_cont(true);
246        });
247
248        // Enable timer outputs
249        T::regs().oenr().modify(|w| {
250            w.set_t1oen(C::raw(), true);
251            w.set_t2oen(C::raw(), true);
252        });
253
254        // The dead-time generation unit cannot be used because it forces the other output
255        // to be completely complementary to the first output, which restricts certain waveforms
256        // Therefore, software-implemented dead time must be used when setting the duty cycles
257
258        // Set output 1 to active on a period event
259        T::regs().tim(C::raw()).setr(0).modify(|w| w.set_per(true));
260
261        // Set output 1 to inactive on a compare 1 event
262        T::regs().tim(C::raw()).rstr(0).modify(|w| w.set_cmp(0, true));
263
264        // Set output 2 to active on a compare 2 event
265        T::regs().tim(C::raw()).setr(1).modify(|w| w.set_cmp(1, true));
266
267        // Set output 2 to inactive on a compare 3 event
268        T::regs().tim(C::raw()).rstr(1).modify(|w| w.set_cmp(2, true));
269
270        Self {
271            timer: PhantomData,
272            channel: PhantomData,
273            dead_time: 0,
274            primary_duty: 0,
275            min_secondary_duty: 0,
276            max_secondary_duty: 0,
277        }
278    }
279
280    /// Start HRTIM.
281    pub fn start(&mut self) {
282        T::regs().mcr().modify(|w| w.set_tcen(C::raw(), true));
283    }
284
285    /// Stop HRTIM.
286    pub fn stop(&mut self) {
287        T::regs().mcr().modify(|w| w.set_tcen(C::raw(), false));
288    }
289
290    /// Enable burst mode.
291    pub fn enable_burst_mode(&mut self) {
292        T::regs().tim(C::raw()).outr().modify(|w| {
293            // Enable Burst Mode
294            w.set_idlem(0, true);
295            w.set_idlem(1, true);
296
297            // Set output to active during the burst
298            w.set_idles(0, true);
299            w.set_idles(1, true);
300        })
301    }
302
303    /// Disable burst mode.
304    pub fn disable_burst_mode(&mut self) {
305        T::regs().tim(C::raw()).outr().modify(|w| {
306            // Disable Burst Mode
307            w.set_idlem(0, false);
308            w.set_idlem(1, false);
309        })
310    }
311
312    fn update_primary_duty_or_dead_time(&mut self) {
313        self.min_secondary_duty = self.primary_duty + self.dead_time;
314
315        T::regs().tim(C::raw()).cmp(0).modify(|w| w.set_cmp(self.primary_duty));
316        T::regs()
317            .tim(C::raw())
318            .cmp(1)
319            .modify(|w| w.set_cmp(self.min_secondary_duty));
320    }
321
322    /// Set the dead time as a proportion of the maximum compare value
323    pub fn set_dead_time(&mut self, dead_time: u16) {
324        self.dead_time = dead_time;
325        self.max_secondary_duty = self.get_max_compare_value() - dead_time;
326        self.update_primary_duty_or_dead_time();
327    }
328
329    /// Get the maximum compare value of a duty cycle
330    pub fn get_max_compare_value(&mut self) -> u16 {
331        T::regs().tim(C::raw()).per().read().per()
332    }
333
334    /// The primary duty is the period in which the primary switch is active
335    ///
336    /// In the case of a buck converter, this is the high-side switch
337    /// In the case of a boost converter, this is the low-side switch
338    pub fn set_primary_duty(&mut self, primary_duty: u16) {
339        self.primary_duty = primary_duty;
340        self.update_primary_duty_or_dead_time();
341    }
342
343    /// The secondary duty is the period in any switch is active
344    ///
345    /// If less than or equal to the primary duty, the secondary switch will be active for one tick
346    /// If a fully complementary output is desired, the secondary duty can be set to the max compare
347    pub fn set_secondary_duty(&mut self, secondary_duty: u16) {
348        let secondary_duty = if secondary_duty > self.max_secondary_duty {
349            self.max_secondary_duty
350        } else if secondary_duty <= self.min_secondary_duty {
351            self.min_secondary_duty + 1
352        } else {
353            secondary_duty
354        };
355
356        T::regs().tim(C::raw()).cmp(2).modify(|w| w.set_cmp(secondary_duty));
357    }
358}
359
360/// Variable-frequency resonant converter driver.
361///
362/// This implementation of a resonsant converter is appropriate for a half or full bridge,
363/// but does not include secondary rectification, which is appropriate for applications
364/// with a low-voltage on the secondary side.
365pub struct ResonantConverter<T: Instance, C: AdvancedChannel<T>> {
366    timer: PhantomData<T>,
367    channel: PhantomData<C>,
368    min_period: u16,
369    max_period: u16,
370}
371
372impl<T: Instance, C: AdvancedChannel<T>> ResonantConverter<T, C> {
373    /// Create a new variable-frequency resonant converter driver.
374    pub fn new(_channel: C, min_frequency: Hertz, max_frequency: Hertz) -> Self {
375        T::set_channel_frequency(C::raw(), min_frequency);
376
377        // Always enable preload
378        T::regs().tim(C::raw()).cr().modify(|w| {
379            w.set_preen(true);
380            w.set_repu(true);
381
382            w.set_cont(true);
383            w.set_half(true);
384        });
385
386        // Enable timer outputs
387        T::regs().oenr().modify(|w| {
388            w.set_t1oen(C::raw(), true);
389            w.set_t2oen(C::raw(), true);
390        });
391
392        // Dead-time generator can be used in this case because the primary fets
393        // of a resonant converter are always complementary
394        T::regs().tim(C::raw()).outr().modify(|w| w.set_dten(true));
395
396        let max_period = T::regs().tim(C::raw()).per().read().per();
397        let min_period = max_period * (min_frequency.0 / max_frequency.0) as u16;
398
399        Self {
400            timer: PhantomData,
401            channel: PhantomData,
402            min_period: min_period,
403            max_period: max_period,
404        }
405    }
406
407    /// Set the dead time as a proportion of the maximum compare value
408    pub fn set_dead_time(&mut self, value: u16) {
409        T::set_channel_dead_time(C::raw(), value);
410    }
411
412    /// Set the timer period.
413    pub fn set_period(&mut self, period: u16) {
414        assert!(period < self.max_period);
415        assert!(period > self.min_period);
416
417        T::regs().tim(C::raw()).per().modify(|w| w.set_per(period));
418    }
419
420    /// Get the minimum compare value of a duty cycle
421    pub fn get_min_period(&mut self) -> u16 {
422        self.min_period
423    }
424
425    /// Get the maximum compare value of a duty cycle
426    pub fn get_max_period(&mut self) -> u16 {
427        self.max_period
428    }
429}
430
431pin_trait!(ChannelAPin, Instance);
432pin_trait!(ChannelAComplementaryPin, Instance);
433pin_trait!(ChannelBPin, Instance);
434pin_trait!(ChannelBComplementaryPin, Instance);
435pin_trait!(ChannelCPin, Instance);
436pin_trait!(ChannelCComplementaryPin, Instance);
437pin_trait!(ChannelDPin, Instance);
438pin_trait!(ChannelDComplementaryPin, Instance);
439pin_trait!(ChannelEPin, Instance);
440pin_trait!(ChannelEComplementaryPin, Instance);
441#[cfg(hrtim_v2)]
442pin_trait!(ChannelFPin, Instance);
443#[cfg(hrtim_v2)]
444pin_trait!(ChannelFComplementaryPin, Instance);
embassy_stm32/hrtim/mod.rs

embassy_stm32/hrtim/
mod.rs
