idle state

Author: burrbull

src/timer.rs

@@ -64,6 +64,13 @@ pub enum Polarity {
     ActiveLow,
 }
 
+/// Output Idle state
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum IdleState {
+    Reset,
+    Set,
+}
+
 /// Interrupt events
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -239,7 +246,7 @@ pub type CCR4<T> = CCR<T, 3>;
 pub struct DMAR<T>(T);
 
 mod sealed {
-    use super::{Channel, Event, Ocm, Polarity};
+    use super::{Channel, Event, Ocm, Polarity, IdleState};
     pub trait General {
         type Width: Into<u32> + From<u16>;
         fn max_auto_reload() -> u32;
@@ -266,6 +273,7 @@ mod sealed {
 
     pub trait WithPwmCommon: General {
         const CH_NUMBER: u8;
+        const COMP_CH_NUMBER: u8;
         fn read_cc_value(channel: u8) -> u32;
         fn set_cc_value(channel: u8, value: u32);
         fn enable_channel(channel: u8, b: bool);
@@ -277,6 +285,7 @@ mod sealed {
         fn enable_nchannel(channel: u8, b: bool);
         fn set_dtg_value(value: u8);
         fn read_dtg_value() -> u8;
+        fn idle_state(channel: u8, comp: bool, s: IdleState);
     }
 
     pub trait WithPwm: WithPwmCommon {
@@ -411,6 +420,7 @@ macro_rules! hal {
             $(
                 impl WithPwmCommon for $TIM {
                     const CH_NUMBER: u8 = $cnum;
+                    const COMP_CH_NUMBER: u8 = $cnum;
 
                     #[inline(always)]
                     fn read_cc_value(c: u8) -> u32 {
@@ -450,7 +460,7 @@ macro_rules! hal {
                     #[inline(always)]
                     fn set_nchannel_polarity(c: u8, p: Polarity) {
                         let tim = unsafe { &*<$TIM>::ptr() };
-                        if c < Self::CH_NUMBER {
+                        if c < Self::COMP_CH_NUMBER {
                             unsafe { bb::write(&tim.ccer, c*4 + 3, p == Polarity::ActiveLow); }
                         }
                     }
@@ -461,7 +471,7 @@ macro_rules! hal {
                         fn enable_nchannel(c: u8, b: bool) {
                             let $aoe = ();
                             let tim = unsafe { &*<$TIM>::ptr() };
-                            if c < Self::CH_NUMBER {
+                            if c < Self::COMP_CH_NUMBER {
                                 unsafe { bb::write(&tim.ccer, c*4 + 2, b); }
                             }
                         }
@@ -473,6 +483,15 @@ macro_rules! hal {
                             let tim = unsafe { &*<$TIM>::ptr() };
                             tim.bdtr.read().dtg().bits()
                         }
+                        fn idle_state(c: u8, comp: bool, s: IdleState) {
+                            let tim = unsafe { &*<$TIM>::ptr() };
+                            if !comp && (c < Self::CH_NUMBER) {
+                                unsafe { bb::write(&tim.cr2, c*2 + 8, s == IdleState::Set); }
+                            }
+                            if comp && (c < Self::COMP_CH_NUMBER) {
+                                unsafe { bb::write(&tim.cr2, c*2 + 9, s == IdleState::Set); }
+                            }
+                        }
                     }
                 )?
 

src/timer/pwm.rs

@@ -34,7 +34,7 @@
 //! and change their polarity with `set_polarity` and `set_complementary_polarity`.
 
 use super::{
-    compute_arr_presc, Advanced, Channel, FTimer, Instance, Ocm, Polarity, Timer, WithPwm,
+    compute_arr_presc, Advanced, Channel, FTimer, Instance, Ocm, Polarity, Timer, WithPwm, IdleState,
 };
 use crate::rcc::Clocks;
 use core::marker::PhantomData;
@@ -263,6 +263,16 @@ impl<TIM: Instance + WithPwm + Advanced, const C: u8> PwmChannel<TIM, C, true> {
     pub fn enable_complementary(&mut self) {
         TIM::enable_nchannel(C, true);
     }
+
+    #[inline]
+    pub fn set_idle_state(&mut self, s: IdleState) {
+        TIM::idle_state(C, false, s);
+    }
+
+    #[inline]
+    pub fn set_complementary_idle_state(&mut self, s: IdleState) {
+        TIM::idle_state(C, true, s);
+    }
 }
 
 pub struct PwmHz<TIM, P, PINS>
@@ -412,22 +422,36 @@ where
     TIM: Instance + WithPwm + Advanced,
     PINS: Pins<TIM, P>,
 {
+    #[inline]
     pub fn enable_complementary(&mut self, channel: Channel) {
         TIM::enable_nchannel(PINS::check_complementary_used(channel) as u8, true)
     }
 
+    #[inline]
     pub fn disable_complementary(&mut self, channel: Channel) {
         TIM::enable_nchannel(PINS::check_complementary_used(channel) as u8, false)
     }
 
+    #[inline]
     pub fn set_dead_time(&mut self, dts_ticks: u16) {
         let bits = pack_ceil_dead_time(dts_ticks);
         TIM::set_dtg_value(bits);
     }
 
+    #[inline]
     pub fn get_dead_time(&self) -> u16 {
         unpack_dead_time(TIM::read_dtg_value())
     }
+
+    #[inline]
+    pub fn set_idle_state(&mut self, channel: Channel, s: IdleState) {
+        TIM::idle_state(PINS::check_used(channel) as u8, false, s);
+    }
+
+    #[inline]
+    pub fn set_complementary_idle_state(&mut self, channel: Channel, s: IdleState) {
+        TIM::idle_state(PINS::check_complementary_used(channel) as u8, true, s);
+    }
 }
 
 pub struct Pwm<TIM, P, PINS, const FREQ: u32>
@@ -578,22 +602,36 @@ where
     TIM: Instance + WithPwm + Advanced,
     PINS: Pins<TIM, P>,
 {
+    #[inline]
     pub fn enable_complementary(&mut self, channel: Channel) {
         TIM::enable_nchannel(PINS::check_complementary_used(channel) as u8, true)
     }
 
+    #[inline]
     pub fn disable_complementary(&mut self, channel: Channel) {
         TIM::enable_nchannel(PINS::check_complementary_used(channel) as u8, false)
     }
 
+    #[inline]
     pub fn set_dead_time(&mut self, dts_ticks: u16) {
         let bits = pack_ceil_dead_time(dts_ticks);
         TIM::set_dtg_value(bits);
     }
 
+    #[inline]
     pub fn get_dead_time(&self) -> u16 {
         unpack_dead_time(TIM::read_dtg_value())
     }
+
+    #[inline]
+    pub fn set_idle_state(&mut self, channel: Channel, s: IdleState) {
+        TIM::idle_state(PINS::check_used(channel) as u8, false, s);
+    }
+
+    #[inline]
+    pub fn set_complementary_idle_state(&mut self, channel: Channel, s: IdleState) {
+        TIM::idle_state(PINS::check_complementary_used(channel) as u8, true, s);
+    }
 }
 
 const fn pack_ceil_dead_time(dts_ticks: u16) -> u8 {