use core::convert::{From, TryFrom};
use num_traits::float::Float;
use crate::hal::timer::{CountDown, Periodic};
#[cfg(any(
feature = "stm32f301",
feature = "stm32f302",
feature = "stm32f303",
feature = "stm32f334",
feature = "stm32f318",
feature = "stm32f328",
feature = "stm32f358",
feature = "stm32f398",
))]
use crate::pac::TIM1;
#[cfg(any(
feature = "stm32f303",
feature = "stm32f328",
feature = "stm32f358",
feature = "stm32f398"
))]
use crate::pac::TIM20;
#[cfg(any(
feature = "stm32f303",
feature = "stm32f328",
feature = "stm32f358",
feature = "stm32f373",
feature = "stm32f378",
feature = "stm32f398"
))]
use crate::pac::TIM4;
#[cfg(any(
feature = "stm32f303",
feature = "stm32f328",
feature = "stm32f358",
feature = "stm32f398",
))]
use crate::pac::TIM8;
#[cfg(any(feature = "stm32f373", feature = "stm32f378"))]
use crate::pac::{TIM12, TIM13, TIM14, TIM18, TIM19, TIM5};
use crate::pac::{TIM15, TIM16, TIM17, TIM2, TIM6};
#[cfg(any(
feature = "stm32f303",
feature = "stm32f328",
feature = "stm32f334",
feature = "stm32f358",
feature = "stm32f373",
feature = "stm32f378",
feature = "stm32f398"
))]
use crate::pac::{TIM3, TIM7};
use void::Void;
use crate::{
clocks,
rcc::{Clocks, APB1, APB2},
time::Hertz,
};
#[derive(Clone, Copy)]
pub struct ValueError {}
pub trait PclkSrc {
fn get_clk(clocks: &Clocks) -> Hertz;
}
pub struct Timer<TIM> {
clocks: Clocks,
tim: TIM,
}
pub enum Event {
Update,
}
#[derive(Clone, Copy, Debug)]
pub enum Alignment {
Edge,
Center1,
Center2,
Center3,
}
#[derive(Clone, Copy, Debug)]
pub enum Channel {
One,
Two,
Three,
Four,
}
#[repr(u8)]
#[derive(Clone, Copy, Debug)]
pub enum CaptureCompare {
Output = 0b00,
InputTi1 = 0b01,
InputTi2 = 0b10,
InputTrc = 0b11,
}
#[derive(Clone, Copy, Debug)]
pub enum Polarity {
ActiveHigh,
ActiveLow,
}
#[cfg(feature = "stm32f303")]
impl Polarity {
fn bit(&self) -> bool {
match self {
Self::ActiveHigh => false,
Self::ActiveLow => true,
}
}
}
#[derive(Clone, Copy, Debug)]
#[repr(u8)]
pub enum OutputCompare {
Frozen = 0b0000,
Active = 0b0001,
Inactive = 0b0010,
ForceInactive = 0b0100,
ForceActive = 0b0101,
Pwm1 = 0b0110,
Pwm2 = 0b0111,
RetriggerableOpmMode1 = 0b1000,
RetriggerableOpmMode2 = 0b1001,
CombinedPwm1 = 0b1100,
CombinedPwm2 = 0b1101,
AsymmetricPwm1 = 0b1110,
AsymmetricPwm2 = 0b1111,
}
impl OutputCompare {
pub fn left_bit(&self) -> bool {
matches!(
self,
Self::RetriggerableOpmMode1
| Self::RetriggerableOpmMode2
| Self::CombinedPwm1
| Self::CombinedPwm2
| Self::AsymmetricPwm1
| Self::AsymmetricPwm2
)
}
}
macro_rules! hal {
($({
$TIMX:ident: ($tim:ident, $timXen:ident, $timXrst:ident),
$APB:ident: ($apb:ident, $pclkX:ident),
},)+) => {
$(
impl PclkSrc for $TIMX {
fn get_clk(clocks: &Clocks) -> Hertz {
clocks.$pclkX()
}
}
impl Periodic for Timer<$TIMX> {}
impl CountDown for Timer<$TIMX> {
type Time = Hertz;
fn start<T>(&mut self, timeout: T)
where
T: Into<Hertz>,
{
self.stop();
let frequency = timeout.into().0;
let timer_clock = $TIMX::get_clk(&self.clocks);
let ticks = timer_clock.0 * if self.clocks.ppre1() == 1 { 1 } else { 2 }
/ frequency;
let psc = crate::unwrap!(u16::try_from((ticks - 1) / (1 << 16)).ok());
self.tim.psc.write(|w| w.psc().bits(psc));
let arr = crate::unwrap!(u16::try_from(ticks / u32::from(psc + 1)).ok());
self.tim.arr.write(|w| unsafe { w.bits(u32::from(arr)) });
self.tim.egr.write(|w| w.ug().update());
self.clear_update_interrupt_flag();
self.tim.cr1.modify(|_, w| w.cen().enabled());
}
fn wait(&mut self) -> nb::Result<(), Void> {
if self.tim.sr.read().uif().is_clear() {
Err(nb::Error::WouldBlock)
} else {
self.clear_update_interrupt_flag();
Ok(())
}
}
}
impl Timer<$TIMX> {
pub fn $tim<T>(tim: $TIMX, timeout: T, clocks: Clocks, $apb: &mut $APB) -> Self
where
T: Into<Hertz>,
{
$apb.enr().modify(|_, w| w.$timXen().enabled());
$apb.rstr().modify(|_, w| w.$timXrst().reset());
$apb.rstr().modify(|_, w| w.$timXrst().clear_bit());
let mut timer = Timer { clocks, tim };
timer.start(timeout);
timer
}
pub fn listen(&mut self, event: Event) {
match event {
Event::Update => self.tim.dier.write(|w| w.uie().enabled()),
}
}
pub fn unlisten(&mut self, event: Event) {
match event {
Event::Update => self.tim.dier.write(|w| w.uie().disabled()),
}
}
pub fn stop(&mut self) {
self.tim.cr1.modify(|_, w| w.cen().disabled());
}
pub fn clear_update_interrupt_flag(&mut self) {
self.tim.sr.modify(|_, w| w.uif().clear());
}
pub fn release(mut self) -> $TIMX {
self.stop();
self.tim
}
pub fn set_period(&mut self, period: f32, clocks: &clocks::Clocks) -> Result<(), ValueError> {
let tim_clk = clocks.calc_speeds().pclk1 * 1_000_000. * 2.;
let max_val = 65_535;
let rhs = tim_clk * period;
let arr = (rhs.sqrt() - 1.) as u16;
let psc = arr;
if arr > max_val || psc > max_val {
return Err(ValueError {})
}
self.tim.arr.write(|w| unsafe { w.bits(u32::from(arr)) });
self.tim.psc.write(|w| unsafe { w.bits(u32::from(psc)) });
Ok(())
}
pub fn reset_countdown(&mut self) {
self.tim.cnt.write(|w| unsafe { w.bits(0) });
}
}
)+
}
}
#[cfg(feature = "stm32f303")]
macro_rules! pwm_features {
($({
$TIMX:ident: ($tim:ident, $timXen:ident, $timXrst:ident),
$APB:ident: ($apb:ident, $pclkX:ident),
$res:ident,
},)+) => {
$(
impl Timer<$TIMX> {
pub fn set_resolution(&mut self, word: $res) {
self.tim.arr.write(|w| w.arr().bits(word) );
}
pub fn set_output_compare(&mut self, channel: Channel, mode: OutputCompare) {
match channel {
Channel::One => {
self.tim.ccmr1_output().modify(|_, w| w.oc1m().bits(mode as u8));
self.tim.ccmr1_output().modify(|_, w| w.oc1m_3().bit(mode.left_bit()));
}
Channel::Two => {
self.tim.ccmr1_output().modify(|_, w| w.oc2m().bits(mode as u8));
self.tim.ccmr1_output().modify(|_, w| w.oc2m_3().bit(mode.left_bit()));
}
Channel::Three => {
self.tim.ccmr2_output().modify(|_, w| w.oc3m().bits(mode as u8));
self.tim.ccmr2_output().modify(|_, w| w.oc3m_3().bit(mode.left_bit()));
}
Channel::Four => {
self.tim.ccmr2_output().modify(|_, w| w.oc4m().bits(mode as u8));
self.tim.ccmr2_output().modify(|_, w| w.oc4m_3().bit(mode.left_bit()));
}
}
}
pub fn get_duty(&self, channel: Channel) -> $res {
match channel {
Channel::One => self.tim.ccr1.read().ccr().bits(),
Channel::Two => self.tim.ccr2.read().ccr().bits(),
Channel::Three => self.tim.ccr3.read().ccr().bits(),
Channel::Four => self.tim.ccr4.read().ccr().bits(),
}
}
pub fn set_duty(&mut self, channel: Channel, duty: $res) {
match channel {
Channel::One => self.tim.ccr1.write(|w| w.ccr().bits(duty)),
Channel::Two => self.tim.ccr2.write(|w| w.ccr().bits(duty)),
Channel::Three => self.tim.ccr3.write(|w| w.ccr().bits(duty)),
Channel::Four => self.tim.ccr4.write(|w| w.ccr().bits(duty)),
}
}
pub fn get_max_duty(&self) -> $res {
self.tim.arr.read().arr().bits()
}
pub fn set_alignment(&mut self, alignment: Alignment) {
let word = match alignment {
Alignment::Edge => 0b00,
Alignment::Center1 => 0b01,
Alignment::Center2 => 0b10,
Alignment::Center3 => 0b11,
};
self.tim.cr1.modify(|_, w| w.cms().bits(word));
}
pub fn set_polarity(&mut self, channel: Channel, polarity: Polarity) {
match channel {
Channel::One => self.tim.ccer.modify(|_, w| w.cc1p().bit(polarity.bit())),
Channel::Two => self.tim.ccer.modify(|_, w| w.cc2p().bit(polarity.bit())),
Channel::Three => self.tim.ccer.modify(|_, w| w.cc3p().bit(polarity.bit())),
Channel::Four => self.tim.ccer.modify(|_, w| w.cc4p().bit(polarity.bit())),
}
}
pub fn set_complementary_polarity(&mut self, channel: Channel, polarity: Polarity) {
match channel {
Channel::One => self.tim.ccer.modify(|_, w| w.cc1np().bit(polarity.bit())),
Channel::Two => self.tim.ccer.modify(|_, w| w.cc2np().bit(polarity.bit())),
Channel::Three => self.tim.ccer.modify(|_, w| w.cc3np().bit(polarity.bit())),
Channel::Four => self.tim.ccer.modify(|_, w| w.cc4np().bit(polarity.bit())),
}
}
pub fn disable(&mut self, channel: Channel) {
match channel {
Channel::One => self.tim.ccer.modify(|_, w| w.cc1e().clear_bit()),
Channel::Two => self.tim.ccer.modify(|_, w| w.cc2e().clear_bit()),
Channel::Three => self.tim.ccer.modify(|_, w| w.cc3e().clear_bit()),
Channel::Four => self.tim.ccer.modify(|_, w| w.cc4e().clear_bit()),
}
}
pub fn enable(&mut self, channel: Channel) {
match channel {
Channel::One => self.tim.ccer.modify(|_, w| w.cc1e().set_bit()),
Channel::Two => self.tim.ccer.modify(|_, w| w.cc2e().set_bit()),
Channel::Three => self.tim.ccer.modify(|_, w| w.cc3e().set_bit()),
Channel::Four => self.tim.ccer.modify(|_, w| w.cc4e().set_bit()),
}
}
pub fn set_capture_compare(&mut self, channel: Channel, mode: CaptureCompare) {
match channel {
Channel::One => self.tim.ccmr1_output().modify( unsafe { |_, w| w.cc1s().bits(mode as u8)} ),
Channel::Two => self.tim.ccmr1_output().modify(unsafe {|_, w| w.cc2s().bits(mode as u8)}),
Channel::Three => self.tim.ccmr2_output().modify(unsafe {|_, w| w.cc3s().bits(mode as u8)}),
Channel::Four => self.tim.ccmr2_output().modify(unsafe {|_, w| w.cc4s().bits(mode as u8)}),
}
}
pub fn set_preload(&mut self, channel: Channel, value: bool) {
match channel {
Channel::One => self.tim.ccmr1_output().modify(|_, w| w.oc1pe().bit(value)),
Channel::Two => self.tim.ccmr1_output().modify(|_, w| w.oc2pe().bit(value)),
Channel::Three => self.tim.ccmr2_output().modify(|_, w| w.oc3pe().bit(value)),
Channel::Four => self.tim.ccmr2_output().modify(|_, w| w.oc4pe().bit(value)),
}
self.tim.egr.write(|w| w.ug().update());
}
}
)+
}
}
#[cfg(any(feature = "stm32f301", feature = "stm32f318"))]
hal! {
{
TIM1: (tim1, tim1en, tim1rst),
APB2: (apb2, pclk2),
},
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
},
{
TIM6: (tim6, tim6en, tim6rst),
APB1: (apb1, pclk1),
},
{
TIM15: (tim15, tim15en, tim15rst),
APB2: (apb2, pclk2),
},
{
TIM16: (tim16, tim16en, tim16rst),
APB2: (apb2, pclk2),
},
{
TIM17: (tim17, tim17en, tim17rst),
APB2: (apb2, pclk2),
},
}
#[cfg(feature = "stm32f302")]
hal! {
{
TIM1: (tim1, tim1en, tim1rst),
APB2: (apb2, pclk2),
},
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
},
{
TIM6: (tim6, tim6en, tim6rst),
APB1: (apb1,pclk1),
},
{
TIM15: (tim15, tim15en, tim15rst),
APB2: (apb2, pclk2),
},
{
TIM16: (tim16, tim16en, tim16rst),
APB2: (apb2, pclk2),
},
{
TIM17: (tim17, tim17en, tim17rst),
APB2: (apb2, pclk2),
},
}
#[cfg(feature = "stm32f303")]
hal! {
{
TIM1: (tim1, tim1en, tim1rst),
APB2: (apb2, pclk2),
},
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
},
{
TIM3: (tim3, tim3en, tim3rst),
APB1: (apb1, pclk1),
},
{
TIM4: (tim4, tim4en, tim4rst),
APB1: (apb1, pclk1),
},
{
TIM6: (tim6, tim6en, tim6rst),
APB1: (apb1, pclk1),
},
{
TIM7: (tim7, tim7en, tim7rst),
APB1: (apb1, pclk1),
},
{
TIM8: (tim8, tim8en, tim8rst),
APB2: (apb2, pclk2),
},
{
TIM15: (tim15, tim15en, tim15rst),
APB2: (apb2, pclk2),
},
{
TIM16: (tim16, tim16en, tim16rst),
APB2: (apb2, pclk2),
},
{
TIM17: (tim17, tim17en, tim17rst),
APB2: (apb2, pclk2),
},
{
TIM20: (tim20, tim20en, tim20rst),
APB2: (apb2, pclk2),
},
}
#[cfg(feature = "stm32f334")]
hal! {
{
TIM1: (tim1, tim1en, tim1rst),
APB2: (apb2, pclk2),
},
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
},
{
TIM3: (tim3, tim3en, tim3rst),
APB1: (apb1, pclk1),
},
{
TIM6: (tim6, tim6en, tim6rst),
APB1: (apb1, pclk1),
},
{
TIM7: (tim7, tim7en, tim7rst),
APB1: (apb1, pclk1),
},
{
TIM15: (tim15, tim15en, tim15rst),
APB2: (apb2, pclk2),
},
{
TIM16: (tim16, tim16en, tim16rst),
APB2: (apb2, pclk2),
},
{
TIM17: (tim17, tim17en, tim17rst),
APB2: (apb2, pclk2),
},
}
#[cfg(any(feature = "stm32f373", feature = "stm32f378"))]
hal! {
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
},
{
TIM3: (tim3, tim3en, tim3rst),
APB1: (apb1, pclk1),
},
{
TIM4: (tim4, tim4en, tim4rst),
APB1: (apb1, pclk1),
},
{
TIM5: (tim5, tim5en, tim5rst),
APB1: (apb1, pclk1),
},
{
TIM6: (tim6, tim6en, tim6rst),
APB1: (apb1, pclk1),
},
{
TIM7: (tim7, tim7en, tim7rst),
APB1: (apb1, pclk1),
},
{
TIM12: (tim12, tim12en, tim12rst),
APB1: (apb1, pclk1),
},
{
TIM13: (tim13, tim13en, tim13rst),
APB1: (apb1, pclk1),
},
{
TIM14: (tim14, tim14en, tim14rst),
APB1: (apb1, pclk1),
},
{
TIM15: (tim15, tim15en, tim15rst),
APB2: (apb2, pclk2),
},
{
TIM16: (tim16, tim16en, tim16rst),
APB2: (apb2, pclk2),
},
{
TIM17: (tim17, tim17en, tim17rst),
APB2: (apb2, pclk2),
},
{
TIM18: (tim18, tim18en, tim18rst),
APB1: (apb1, pclk1),
},
{
TIM19: (tim19, tim19en, tim19rst),
APB2: (apb2, pclk2),
},
}
#[cfg(any(feature = "stm32f328", feature = "stm32f358", feature = "stm32f398"))]
hal! {
{
TIM1: (tim1, tim1en, tim1rst),
APB2: (apb2, pclk2),
},
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
},
{
TIM3: (tim3, tim3en, tim3rst),
APB1: (apb1, pclk1),
},
{
TIM4: (tim4, tim4en, tim4rst),
APB1: (apb1, pclk1),
},
{
TIM6: (tim6, tim6en, tim6rst),
APB1: (apb1, pclk1),
},
{
TIM7: (tim7, tim7en, tim7rst),
APB1: (apb1, pclk1),
},
{
TIM8: (tim8, tim8en, tim8rst),
APB2: (apb2, pclk2),
},
{
TIM15: (tim15, tim15en, tim15rst),
APB2: (apb2, pclk2),
},
{
TIM16: (tim16, tim16en, tim16rst),
APB2: (apb2, pclk2),
},
{
TIM17: (tim17, tim17en, tim17rst),
APB2: (apb2, pclk2),
},
{
TIM20: (tim20, tim20en, tim20rst),
APB2: (apb2, pclk2),
},
}
#[cfg(feature = "stm32f303")]
pwm_features! {
{
TIM2: (tim2, tim2en, tim2rst),
APB1: (apb1, pclk1),
u32,
},
{
TIM3: (tim3, tim3en, tim3rst),
APB1: (apb1, pclk1),
u16,
},
{
TIM4: (tim4, tim4en, tim4rst),
APB1: (apb1, pclk1),
u16,
},
}