Implement full embedded_hal::Pwm (#176)

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Extend the Pwm implementation to cover the full embedded_hal::Pwm API
 - Replace default blocking spi Write implementation with an optimized one
 - Use `Deref` for SPI generic implementations instead of macros
 - Make traits `rcc::Enable` and `rcc::Reset` public, but `RccBus` sealed

examples/pwm.rs

@@ -11,6 +11,8 @@ use stm32f1xx_hal::{
  prelude::*,
  pac,
  timer::{Tim2NoRemap, Timer},
+ time::U32Ext,
+ pwm::Channel
 };
 use cortex_m_rt::entry;
 
@@ -49,25 +51,56 @@ fn main() -> ! {
  // let c4 = gpiob.pb9.into_alternate_push_pull(&mut gpiob.crh);
 
  let mut pwm = Timer::tim2(p.TIM2, &clocks, &mut rcc.apb1)
- .pwm::<Tim2NoRemap, _, _, _>(pins, &mut afio.mapr, 1.khz())
- .2;
+ .pwm::<Tim2NoRemap, _, _, _>(pins, &mut afio.mapr, 1.khz());
+
+ //// Operations affecting all defined channels on the Timer
+
+ // Adjust period to 0.5 seconds
+ pwm.set_period(500.ms());
+
+ asm::bkpt();
+
+ // Return to the original frequency
+ pwm.set_period(1.khz());
+
+ asm::bkpt();
 
  let max = pwm.get_max_duty();
 
- pwm.enable();
+ //// Operations affecting single channels can be accessed through
+ //// the Pwm object or via dereferencing to the pin.
+
+ // Use the Pwm object to set C3 to full strength
+ pwm.set_duty(Channel::C3, max);
+
+ asm::bkpt();
+
+ // Use the Pwm object to set C3 to be dim
+ pwm.set_duty(Channel::C3, max / 4);
+
+ asm::bkpt();
+
+ // Use the Pwm object to set C3 to be zero
+ pwm.set_duty(Channel::C3, 0);
+
+ asm::bkpt();
+
+
+ // Extract the PwmChannel for C3
+ let mut pwm_channel = pwm.split().2;
 
- // full
- pwm.set_duty(max);
+ // Use the PwmChannel object to set C3 to be full strength
+ pwm_channel.set_duty(max);
 
  asm::bkpt();
 
- // dim
- pwm.set_duty(max / 4);
+ // Use the PwmChannel object to set C3 to be dim
+ pwm_channel.set_duty(max / 4);
 
  asm::bkpt();
 
- // zero
- pwm.set_duty(0);
+ // Use the PwmChannel object to set C3 to be zero
+ pwm_channel.set_duty(0);
 
  asm::bkpt();
 

examples/pwm_custom.rs

@@ -33,28 +33,31 @@ fn main() -> ! {
  let p0 = pb4.into_alternate_push_pull(&mut gpiob.crl);
  let p1 = gpiob.pb5.into_alternate_push_pull(&mut gpiob.crl);
 
- let mut pwm = Timer::tim3(p.TIM3, &clocks, &mut rcc.apb1)
+ let pwm = Timer::tim3(p.TIM3, &clocks, &mut rcc.apb1)
  .pwm((p0, p1), &mut afio.mapr, 1.khz());
 
- let max = pwm.0.get_max_duty();
+ let max = pwm.get_max_duty();
 
- pwm.0.enable();
- pwm.1.enable();
+ let mut pwm_channels = pwm.split();
+
+ // Enable the individual channels 
+ pwm_channels.0.enable();
+ pwm_channels.1.enable();
 
  // full
- pwm.0.set_duty(max);
- pwm.1.set_duty(max);
+ pwm_channels.0.set_duty(max);
+ pwm_channels.1.set_duty(max);
 
  asm::bkpt();
 
  // dim
- pwm.1.set_duty(max / 4);
+ pwm_channels.1.set_duty(max / 4);
 
  asm::bkpt();
 
  // zero
- pwm.0.set_duty(0);
- pwm.1.set_duty(0);
+ pwm_channels.0.set_duty(0);
+ pwm_channels.1.set_duty(0);
 
  asm::bkpt();
 

src/pwm.rs

@@ -54,6 +54,7 @@
 */
 
 use core::marker::PhantomData;
+use core::marker::{Copy};
 use core::mem;
 
 use crate::hal;
@@ -68,6 +69,7 @@ use crate::afio::MAPR;
 use crate::bb;
 use crate::gpio::{self, Alternate, PushPull};
 use crate::time::Hertz;
+use crate::time::U32Ext;
 use crate::timer::Timer;
 
 pub trait Pins<REMAP, P> {
@@ -76,6 +78,26 @@ pub trait Pins<REMAP, P> {
  const C3: bool = false;
  const C4: bool = false;
  type Channels;
+
+ fn check_used(c: Channel) -> Channel {
+ if (c == Channel::C1 && Self::C1)
+ || (c == Channel::C2 && Self::C2)
+ || (c == Channel::C3 && Self::C3)
+ || (c == Channel::C4 && Self::C4)
+ {
+ c
+ } else {
+ panic!("Unused channel")
+ }
+ }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Channel {
+ C1,
+ C2,
+ C3,
+ C4,
 }
 
 use crate::timer::sealed::{Ch1, Ch2, Ch3, Ch4, Remap};
@@ -89,7 +111,7 @@ macro_rules! pins_impl {
  $($PINX: $TRAIT<REMAP> + gpio::Mode<Alternate<PushPull>>,)+
  {
  $(const $ENCHX: bool = true;)+
- type Channels = ($(Pwm<TIM, $ENCHX>),+);
+ type Channels = ($(PwmChannel<TIM, $ENCHX>),+);
  }
  )+
  };
@@ -115,7 +137,7 @@ pins_impl!(
 
 #[cfg(any(feature = "stm32f100", feature = "stm32f103", feature = "stm32f105",))]
 impl Timer<TIM1> {
- pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> PINS::Channels
+ pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> Pwm<TIM1, REMAP, P, PINS>
  where
  REMAP: Remap<Periph = TIM1>,
  PINS: Pins<REMAP, P>,
@@ -133,7 +155,7 @@ impl Timer<TIM1> {
 }
 
 impl Timer<TIM2> {
- pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> PINS::Channels
+ pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> Pwm<TIM2, REMAP, P, PINS>
  where
  REMAP: Remap<Periph = TIM2>,
  PINS: Pins<REMAP, P>,
@@ -147,7 +169,7 @@ impl Timer<TIM2> {
 }
 
 impl Timer<TIM3> {
- pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> PINS::Channels
+ pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> Pwm<TIM3, REMAP, P, PINS>
  where
  REMAP: Remap<Periph = TIM3>,
  PINS: Pins<REMAP, P>,
@@ -162,7 +184,7 @@ impl Timer<TIM3> {
 
 #[cfg(feature = "medium")]
 impl Timer<TIM4> {
- pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> PINS::Channels
+ pub fn pwm<REMAP, P, PINS, T>(self, _pins: PINS, mapr: &mut MAPR, freq: T) -> Pwm<TIM4, REMAP, P, PINS>
  where
  REMAP: Remap<Periph = TIM4>,
  PINS: Pins<REMAP, P>,
@@ -175,7 +197,26 @@ impl Timer<TIM4> {
  }
 }
 
-pub struct Pwm<TIM, CHANNEL> {
+pub struct Pwm<TIM, REMAP, P, PINS>
+where
+ REMAP: Remap<Periph = TIM>,
+ PINS: Pins<REMAP, P>
+{
+ clk: Hertz,
+ _pins: PhantomData<(TIM, REMAP, P, PINS)>,
+}
+
+impl<TIM, REMAP, P, PINS> Pwm<TIM, REMAP, P, PINS>
+where
+ REMAP: Remap<Periph = TIM>,
+ PINS: Pins<REMAP, P>
+{
+ pub fn split(self) -> PINS::Channels {
+ unsafe { mem::MaybeUninit::uninit().assume_init() }
+ }
+}
+
+pub struct PwmChannel<TIM, CHANNEL> {
  _channel: PhantomData<CHANNEL>,
  _tim: PhantomData<TIM>,
 }
@@ -193,7 +234,7 @@ macro_rules! hal {
  _pins: PINS,
  freq: Hertz,
  clk: Hertz,
- ) -> PINS::Channels
+ ) -> Pwm<$TIMX, REMAP, P, PINS>
  where
  REMAP: Remap<Periph = $TIMX>,
  PINS: Pins<REMAP, P>,
@@ -240,10 +281,97 @@ macro_rules! hal {
  .set_bit()
  );
 
- unsafe { mem::MaybeUninit::uninit().assume_init() }
+ Pwm {
+ clk: clk,
+ _pins: PhantomData
+ }
+ }
+
+ /*
+ The following implemention of the embedded_hal::Pwm uses Hertz as a time type. This was choosen 
+ because of the timescales of operations being on the order of nanoseconds and not being able to 
+ efficently represent a float on the hardware. It might be possible to change the time type to
+ a different time based using such as the nanosecond. The issue with doing so is that the max 
+ delay would then be at just a little over 2 seconds because of the 32 bit depth of the number.
+ Using milliseconds is also an option, however, using this as a base unit means that only there 
+ could be resolution issues when trying to get a specific value, because of the integer nature.
+
+ To find a middle ground, the Hertz type is used as a base here and the Into trait has been 
+ defined for several base time units. This will allow for calling the set_period method with 
+ something that is natural to both the MCU and the end user.
+ */
+ impl<REMAP, P, PINS> hal::Pwm for Pwm<$TIMX, REMAP, P, PINS> where
+ REMAP: Remap<Periph = $TIMX>,
+ PINS: Pins<REMAP, P>,
+ {
+ type Channel = Channel;
+ type Duty = u16;
+ type Time = Hertz;
+
+ fn enable(&mut self, channel: Self::Channel) {
+ match PINS::check_used(channel) {
+ Channel::C1 => unsafe { bb::set(&(*$TIMX::ptr()).ccer, 0) },
+ Channel::C2 => unsafe { bb::set(&(*$TIMX::ptr()).ccer, 4) },
+ Channel::C3 => unsafe { bb::set(&(*$TIMX::ptr()).ccer, 8) },
+ Channel::C4 => unsafe { bb::set(&(*$TIMX::ptr()).ccer, 12) }
+ }
+ }
+
+ fn disable(&mut self, channel: Self::Channel) {
+ match PINS::check_used(channel) {
+ Channel::C1 => unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 0) },
+ Channel::C2 => unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 4) },
+ Channel::C3 => unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 8) },
+ Channel::C4 => unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 12) },
+ }
+ }
+
+ fn get_duty(&self, channel: Self::Channel) -> Self::Duty {
+ match PINS::check_used(channel) {
+ Channel::C1 => unsafe { (*$TIMX::ptr()).ccr1.read().ccr().bits() },
+ Channel::C2 => unsafe { (*$TIMX::ptr()).ccr2.read().ccr().bits() },
+ Channel::C3 => unsafe { (*$TIMX::ptr()).ccr3.read().ccr().bits() },
+ Channel::C4 => unsafe { (*$TIMX::ptr()).ccr4.read().ccr().bits() },
+ }
+ }
+
+ fn set_duty(&mut self, channel: Self::Channel, duty: Self::Duty) {
+ match PINS::check_used(channel) {
+ Channel::C1 => unsafe { (*$TIMX::ptr()).ccr1.write(|w| w.ccr().bits(duty)) },
+ Channel::C2 => unsafe { (*$TIMX::ptr()).ccr2.write(|w| w.ccr().bits(duty)) },
+ Channel::C3 => unsafe { (*$TIMX::ptr()).ccr3.write(|w| w.ccr().bits(duty)) },
+ Channel::C4 => unsafe { (*$TIMX::ptr()).ccr4.write(|w| w.ccr().bits(duty)) },
+ }
+ }
+
+ fn get_max_duty(&self) -> Self::Duty {
+ unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }
+ }
+
+ fn get_period(&self) -> Self::Time {
+ let clk = self.clk;
+ let psc: u16 = unsafe{(*$TIMX::ptr()).psc.read().psc().bits()};
+ let arr: u16 = unsafe{(*$TIMX::ptr()).psc.read().psc().bits()};
+
+ // Length in ms of an internal clock pulse
+ (clk.0 / u32(psc * arr)).hz()
+ }
+
+ fn set_period<T>(&mut self, period: T) where
+ T: Into<Self::Time> {
+ let clk = self.clk;
+
+ let ticks = clk.0 / period.into().0;
+ let psc = u16(ticks / (1 << 16)).unwrap();
+ let arr = u16(ticks / u32(psc + 1)).unwrap();
+ unsafe {
+ (*$TIMX::ptr()).psc.write(|w| w.psc().bits(psc));
+ (*$TIMX::ptr()).arr.write(|w| w.arr().bits(arr));
+ }
+ }
  }
 
- impl hal::PwmPin for Pwm<$TIMX, C1> {
+ impl hal::PwmPin for PwmChannel<$TIMX, C1> {
  type Duty = u16;
 
  fn disable(&mut self) {
@@ -267,7 +395,7 @@ macro_rules! hal {
  }
  }
 
- impl hal::PwmPin for Pwm<$TIMX, C2> {
+ impl hal::PwmPin for PwmChannel<$TIMX, C2> {
  type Duty = u16;
 
  fn disable(&mut self) {
@@ -291,7 +419,7 @@ macro_rules! hal {
  }
  }
 
- impl hal::PwmPin for Pwm<$TIMX, C3> {
+ impl hal::PwmPin for PwmChannel<$TIMX, C3> {
  type Duty = u16;
 
  fn disable(&mut self) {
@@ -315,7 +443,7 @@ macro_rules! hal {
  }
  }
 
- impl hal::PwmPin for Pwm<$TIMX, C4> {
+ impl hal::PwmPin for PwmChannel<$TIMX, C4> {
  type Duty = u16;
 
  fn disable(&mut self) {