Merge pull request #45 from nickray/pwm

Intial PWM implementation, currently supporting tim2.

Author: MabezDev

examples/pwm.rs

@@ -0,0 +1,85 @@
+//! Testing PWM output
+
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![no_main]
+#![no_std]
+
+extern crate panic_halt;
+
+// use cortex_m::asm;
+use stm32l4xx_hal::{
+    prelude::*,
+    stm32,
+    delay,
+};
+use cortex_m_rt::entry;
+
+#[entry]
+fn main() -> ! {
+    let c = cortex_m::Peripherals::take().unwrap();
+    let p = stm32::Peripherals::take().unwrap();
+
+    let mut flash = p.FLASH.constrain();
+    let mut rcc = p.RCC.constrain();
+
+    let clocks = rcc.cfgr.freeze(&mut flash.acr);
+
+    let mut gpioa = p.GPIOA.split(&mut rcc.ahb2);
+
+    // TIM2
+    let c1 = gpioa.pa0
+        .into_push_pull_output(&mut gpioa.moder, &mut gpioa.otyper)
+        .into_af1(&mut gpioa.moder, &mut gpioa.afrl);
+    let c2 = gpioa.pa1
+        .into_push_pull_output(&mut gpioa.moder, &mut gpioa.otyper)
+        .into_af1(&mut gpioa.moder, &mut gpioa.afrl);
+    let c3 = gpioa.pa2
+        .into_push_pull_output(&mut gpioa.moder, &mut gpioa.otyper)
+        .into_af1(&mut gpioa.moder, &mut gpioa.afrl);
+    let c4 = gpioa.pa3
+        .into_push_pull_output(&mut gpioa.moder, &mut gpioa.otyper)
+        .into_af1(&mut gpioa.moder, &mut gpioa.afrl);
+
+    let mut pwm = p
+        .TIM2
+        .pwm(
+            (c1, c2, c3, c4),
+            1.khz(),
+            clocks,
+            &mut rcc.apb1r1,
+        )
+        .3;
+
+    let max = pwm.get_max_duty();
+
+    pwm.enable();
+
+    let mut timer = delay::Delay::new(c.SYST, clocks);
+    let second: u32 = 100;
+
+    // NB: if the pins are LEDs, brightness is not
+    //     linear in duty value.
+    loop {
+        pwm.set_duty(max);
+        timer.delay_ms(second);
+        // asm::bkpt();
+
+        pwm.set_duty(max/11*10);
+        timer.delay_ms(second);
+        // asm::bkpt();
+
+        pwm.set_duty(3*max/4);
+        timer.delay_ms(second);
+        // asm::bkpt();
+
+        pwm.set_duty(max/2);
+        timer.delay_ms(second);
+        // asm::bkpt();
+
+        pwm.set_duty(max/4);
+        timer.delay_ms(second);
+        // asm::bkpt();
+
+    }
+}

src/bb.rs

@@ -0,0 +1,36 @@
+//! Bit banding
+
+// seems this is not a HAL trait (yet?)
+// TODO: why is it used
+//
+// "The processor memory map includes two bit-band regions.
+// These occupy the lowest 1MB of the SRAM and Peripheral memory regions respectively.
+// These bit-band regions map each word in an alias region of memory to a bit
+// in a bit-band region of memory."
+//
+// This module only handles peripheral, not SRAM bit-banding
+
+use core::ptr;
+
+pub fn clear<T>(register: *const T, bit: u8) {
+    write(register, bit, false);
+}
+
+pub fn set<T>(register: *const T, bit: u8) {
+    write(register, bit, true);
+}
+
+pub fn write<T>(register: *const T, bit: u8, set: bool) {
+    let addr = register as usize;
+
+    // Peripheral memory starts at 0x4000_0000, the first megabyte is aliased.
+    //
+    // Bit-band region is first megabyte
+    assert!(addr >= 0x4000_0000 && addr <= 0x4010_0000);
+    assert!(bit < 32);
+
+    let bit = bit as usize;
+    // bit_word_addr = bit_band_base + (byte_offset x 32) + (bit_number × 4)
+    let bb_addr = (0x4200_0000 + (addr - 0x4000_0000) * 32) + 4 * bit;
+    unsafe { ptr::write_volatile(bb_addr as *mut u32, if set { 1 } else { 0 }) }
+}

src/gpio.rs

@@ -45,6 +45,11 @@ pub struct Alternate<AF, MODE>
     _mode: PhantomData<MODE>,
 }
 
+pub enum State {
+    High,
+    Low,
+}
+
 /// Alternate function 0 (type state)
 pub struct AF0;
 
@@ -106,8 +111,10 @@ macro_rules! gpio {
 
             use crate::rcc::AHB2;
             use super::{
-                Alternate, AF4, AF5, AF6, AF7, AF8, AF9, Floating, GpioExt, Input, OpenDrain, Output,
-                PullDown, PullUp, PushPull,
+                Alternate,
+                AF1, AF4, AF5, AF6, AF7, AF8, AF9,
+                Floating, GpioExt, Input, OpenDrain, Output,
+                PullDown, PullUp, PushPull, State,
             };
 
             /// GPIO parts
@@ -231,6 +238,29 @@ macro_rules! gpio {
                 }
 
                 impl<MODE> $PXi<MODE> {
+                    /// Configures the pin to serve as alternate function 1 (AF1)
+                    pub fn into_af1(
+                        self,
+                        moder: &mut MODER,
+                        afr: &mut $AFR,
+                    ) -> $PXi<Alternate<AF1, MODE>> {
+                        let offset = 2 * $i;
+
+                        // alternate function mode
+                        let mode = 0b10;
+                        moder.moder().modify(|r, w| unsafe {
+                            w.bits((r.bits() & !(0b11 << offset)) | (mode << offset))
+                        });
+
+                        let af = 1;
+                        let offset = 4 * ($i % 8);
+                        afr.afr().modify(|r, w| unsafe {
+                            w.bits((r.bits() & !(0b1111 << offset)) | (af << offset))
+                        });
+
+                        $PXi { _mode: PhantomData }
+                    }
+
                     /// Configures the pin to serve as alternate function 4 (AF4)
                     pub fn into_af4(
                         self,
@@ -458,11 +488,33 @@ macro_rules! gpio {
                     }
 
                     /// Configures the pin to operate as an push pull output pin
+                    /// Initial state will be low
                     pub fn into_push_pull_output(
                         self,
                         moder: &mut MODER,
                         otyper: &mut OTYPER,
                     ) -> $PXi<Output<PushPull>> {
+                        self.into_push_pull_output_with_state(moder, otyper, State::Low)
+                    }
+
+                    /// Configures the pin to operate as an push pull output pin
+                    /// Initial state can be chosen to be high or low
+                    pub fn into_push_pull_output_with_state(
+                        self,
+                        moder: &mut MODER,
+                        otyper: &mut OTYPER,
+                        initial_state: State,
+                    ) -> $PXi<Output<PushPull>> {
+                        let mut res = $PXi { _mode: PhantomData };
+
+                        // set pin high/low before activating, to prevent
+                        // spurious signals (e.g. LED flash)
+                        // TODO: I still see a flash of LED using this order
+                        match initial_state {
+                            State::High => res.set_high(),
+                            State::Low => res.set_low(),
+                        }
+
                         let offset = 2 * $i;
 
                         // general purpose output mode
@@ -476,7 +528,7 @@ macro_rules! gpio {
                             .otyper()
                             .modify(|r, w| unsafe { w.bits(r.bits() & !(0b1 << $i)) });
 
-                        $PXi { _mode: PhantomData }
+                        res
                     }
 
                     /// Configures the pin to operate as an touch sample

src/lib.rs

@@ -165,3 +165,19 @@ pub mod timer;
     feature = "stm32l4x6"
 ))]
 pub mod tsc;
+#[cfg(any(
+    feature = "stm32l4x1",
+    feature = "stm32l4x2",
+    feature = "stm32l4x3",
+    feature = "stm32l4x5",
+    feature = "stm32l4x6"
+))]
+pub mod bb;
+#[cfg(any(
+    feature = "stm32l4x1",
+    feature = "stm32l4x2",
+    feature = "stm32l4x3",
+    feature = "stm32l4x5",
+    feature = "stm32l4x6"
+))]
+pub mod pwm;

src/prelude.rs

@@ -10,3 +10,4 @@ pub use crate::datetime::U32Ext as _stm32l4_hal_datetime_U32Ext;
 pub use crate::dma::DmaExt as _stm32l4_hal_DmaExt;
 pub use crate::pwr::PwrExt as _stm32l4_hal_PwrExt;
 pub use crate::rng::RngExt as _stm32l4_hal_RngExt;
+pub use crate::pwm::PwmExt as _stm32l4_hal_PwmExt;