Update hrtim examples. TODO: Make sure timers are started

Author: usbalbin

examples/hrtim-adc-trigger.rs renamed to examples/hrtim/adc-trigger.rs

@@ -10,34 +10,51 @@ use crate::hal::{
         AdcClaim, ClockSource, Temperature, Vref,
     },
     delay::SYSTDelayExt,
-    dma::{config::DmaConfig, stream::DMAExt, TransferExt},
-    gpio::GpioExt,
-    rcc::{Config, RccExt},
+    dma::{self, config::DmaConfig, stream::DMAExt, TransferExt},
+    gpio::{gpioa::PA8, gpioa::PA9, Alternate, GpioExt, AF13},
+    hrtim::control::HrControltExt,
+    hrtim::output::HrOutput,
+    hrtim::HrPwmAdvExt,
+    hrtim::{control::Adc13Trigger, Pscl4},
+    pwr::PwrExt,
+    rcc::{self, RccExt},
     stm32::Peripherals,
 };
 use stm32g4xx_hal as hal;
 
-use log::info;
+use defmt::info;
 
-#[macro_use]
-mod utils;
+use defmt_rtt as _; // global logger
+use panic_probe as _;
 
 #[entry]
 fn main() -> ! {
-    utils::logger::init();
-
     info!("start");
 
     let dp = Peripherals::take().unwrap();
     let cp = cortex_m::Peripherals::take().expect("cannot take core peripherals");
 
+    // Set system frequency to 16MHz * 15/1/2 = 120MHz
+    // This would lead to HrTim running at 120MHz * 32 = 3.84...
     info!("rcc");
-    let rcc = dp.RCC.constrain();
-    let mut rcc = rcc.freeze(Config::hsi());
+    let pwr = dp.PWR.constrain().freeze();
+    let mut rcc = dp.RCC.freeze(
+        rcc::Config::pll().pll_cfg(rcc::PllConfig {
+            mux: rcc::PLLSrc::HSI,
+            n: rcc::PllNMul::MUL_15,
+            m: rcc::PllMDiv::DIV_1,
+            r: Some(rcc::PllRDiv::DIV_2),
+
+            ..Default::default()
+        }),
+        pwr,
+    );
+
+    let mut delay = cp.SYST.delay(&rcc.clocks);
 
-    let streams = dp.DMA1.split(&rcc);
+    let dma::stream::StreamsTuple(dma1ch1, ..) = dp.DMA1.split(&rcc);
     let config = DmaConfig::default()
-        .transfer_complete_interrupt(false)
+        .transfer_complete_interrupt(true)
         .circular_buffer(true)
         .memory_increment(true);
 
@@ -46,7 +63,6 @@ fn main() -> ! {
     let pa0 = gpioa.pa0.into_analog();
 
     info!("Setup Adc1");
-    let mut delay = cp.SYST.delay(&rcc.clocks);
     let mut adc = dp
         .ADC1
         .claim(ClockSource::SystemClock, &rcc, &mut delay, true);
@@ -63,40 +79,50 @@ fn main() -> ! {
 
     info!("Setup DMA");
     let first_buffer = cortex_m::singleton!(: [u16; 10] = [0; 10]).unwrap();
-    let mut transfer = streams.0.into_circ_peripheral_to_memory_transfer(
+
+    let mut transfer = dma1ch1.into_circ_peripheral_to_memory_transfer(
         adc.enable_dma(AdcDma::Continuous),
         &mut first_buffer[..],
         config,
     );
 
     transfer.start(|adc| adc.start_conversion());
 
+    let pin_a: PA8<Alternate<AF13>> = gpioa.pa8.into_alternate();
+    let pin_b: PA9<Alternate<AF13>> = gpioa.pa9.into_alternate();
+
+    // ...with a prescaler of 4 this gives us a HrTimer with a tick rate of 960MHz
+    // With max the max period set, this would be 960MHz/2^16 ~= 15kHz...
+    let prescaler = Pscl4;
+
     //        .               .
     //        .  50%          .
     //         ------          ------
     //out1    |      |        |      |
     //        |      |        |      |
     // --------      ----------      --------
-    let (mut fault_control, _) = dp
+    let (hr_control, ..) = dp
         .HRTIM_COMMON
         .hr_control(&mut rcc)
-        .set_adc_trigger1(Adc13Trigger::)
+        .enable_adc_trigger1_source(Adc13Trigger::TimACmp3)
+        .enable_adc_trigger1_source(Adc13Trigger::TimACmp4)
         .wait_for_calibration();
-    let (mut timer, (mut cr1, _cr2, _cr3, _cr4), (mut out1, mut out2)) = dp
+    let mut hr_control = hr_control.constrain();
+    let (timer, (cr1, _cr2, _cr3, _cr4), (mut out1, mut out2)) = dp
         .HRTIM_TIMA
         .pwm_advanced((pin_a, pin_b), &mut rcc)
         .prescaler(prescaler)
         .period(0xFFFF)
         // alternated every period with one being
         // inactive and the other getting to output its wave form
         // as normal
-        .finalize(&mut fault_control);
+        .finalize(&mut hr_control);
 
-    out1.enable_rst_event(EventSource::Cr1); // Set low on compare match with cr1
-    out2.enable_rst_event(EventSource::Cr1);
+    out1.enable_rst_event(&cr1); // Set low on compare match with cr1
+    out2.enable_rst_event(&cr1);
 
-    out1.enable_set_event(EventSource::Period); // Set high at new period
-    out2.enable_set_event(EventSource::Period);
+    out1.enable_set_event(&timer); // Set high at new period
+    out2.enable_set_event(&timer);
 
     out1.enable();
     out2.enable();

examples/hrtim_eev_comp.rs renamed to examples/hrtim/eev-comp.rs

@@ -3,24 +3,23 @@
 #![no_std]
 
 use cortex_m_rt::entry;
-use fugit::ExtU32;
 use hal::comparator;
-use hal::comparator::{Hysteresis, ComparatorSplit, ComparatorExt};
+use hal::comparator::{ComparatorExt, ComparatorSplit, Hysteresis};
 use hal::dac::{self, DacExt, DacOut};
 use hal::gpio::gpioa::PA8;
 use hal::gpio::Alternate;
+use hal::gpio::SignalEdge;
 use hal::gpio::AF13;
 use hal::hrtim::compare_register::HrCompareRegister;
-use hal::hrtim::event::EventSource;
 use hal::hrtim::external_event::{self, ToExternalEventSource};
-use hal::hrtim::timer_eev_cfg::EevCfgs;
 use hal::hrtim::timer::HrTimer;
+use hal::hrtim::timer_eev_cfg::{EevCfg, EevCfgs};
 use hal::hrtim::HrPwmAdvExt;
 use hal::hrtim::Pscl4;
 use hal::hrtim::{control::HrControltExt, output::HrOutput};
 use hal::prelude::*;
 use hal::pwm;
-use hal::pwr::{self, PwrExt};
+use hal::pwr::PwrExt;
 use hal::rcc;
 use hal::stm32;
 use stm32g4xx_hal as hal;
@@ -34,13 +33,7 @@ fn main() -> ! {
     let cp = stm32::CorePeripherals::take().expect("cannot take core");
     // Set system frequency to 16MHz * 75/4/2 = 150MHz
     // This would lead to HrTim running at 150MHz * 32 = 4.8GHz...
-    let pwr = dp
-        .PWR
-        .constrain()
-        .vos(pwr::VoltageScale::Range1 {
-            enable_boost: false,
-        })
-        .freeze();
+    let pwr = dp.PWR.constrain().freeze();
 
     let mut rcc = dp.RCC.freeze(
         rcc::Config::pll().pll_cfg(rcc::PllConfig {
@@ -53,34 +46,34 @@ fn main() -> ! {
         pwr,
     );
 
+    let exti = dp.EXTI;
+
     let mut delay = cp.SYST.delay(&rcc.clocks);
 
     let gpioa = dp.GPIOA.split(&mut rcc);
-    let gpiob = dp.GPIOB.split(&mut rcc);
 
     let input = gpioa.pa1.into_analog();
     let pin_a: PA8<Alternate<AF13>> = gpioa.pa8.into_alternate();
 
-    let dac3ch1 = dp.DAC3.constrain(dac::Dac3IntSig1, &mut rcc);
-    let mut dac = dac3ch1.enable();
+    let dac1ch1 = dp.DAC1.constrain(dac::Dac1IntSig1, &mut rcc);
+    let mut dac = dac1ch1.calibrate_buffer(&mut delay).enable();
 
     // Use dac to define the fault threshold
     // 2^12 / 2 = 2^11 for about half of VCC
-    let fault_limit = 60;
-    dac.set_value(fault_limit);
+    let limit = 1 << 11;
+    dac.set_value(limit);
 
     let (comp1, ..) = dp.COMP.split(&mut rcc);
 
-    let comp1 = comp1
-        .comparator(
-            &input,
-            &dac,
-            comparator::Config::default()
-                .hysteresis(Hysteresis::None),
-                //.output_inverted(),
-            &rcc.clocks,
-        )
-        .enable();
+    let comp1 = comp1.comparator(
+        &input,
+        &dac,
+        comparator::Config::default().hysteresis(Hysteresis::None),
+        //.output_inverted(),
+        &rcc.clocks,
+    );
+    comp1.listen(SignalEdge::Rising, &exti);
+    let comp1 = comp1.enable().lock();
 
     let (mut hr_control, _flt_inputs, eev_inputs) =
         dp.HRTIM_COMMON.hr_control(&mut rcc).wait_for_calibration();
@@ -117,19 +110,25 @@ fn main() -> ! {
         .HRTIM_TIMA
         .pwm_advanced(pin_a, &mut rcc)
         .prescaler(prescaler)
-        .eev_cfg(EevCfgs::default())
+        .eev_cfg(EevCfgs::default().eev4(EevCfg::default()))
         .period(0xFFFF)
         .finalize(&mut hr_control);
 
     out1.enable_rst_event(&cr1); // Set low on compare match with cr1
     out1.enable_rst_event(eev_input4);
     out1.enable_set_event(&timer); // Set high at new period
     cr1.set_duty(timer.get_period() / 3);
-    //unsafe {((HRTIM_COMMON::ptr() as *mut u8).offset(0x14) as *mut u32).write_volatile(1); }
+
     out1.enable();
     timer.start(&mut hr_control);
 
     defmt::info!("Started");
 
-    loop {}
+    loop {
+        defmt::info!(
+            "Comp: {}, pending: {}",
+            comp1.output(),
+            comp1.is_pending(&exti)
+        );
+    }
 }

examples/hrtim_eev.rs renamed to examples/hrtim/eev.rs

@@ -3,21 +3,20 @@
 #![no_std]
 
 use cortex_m_rt::entry;
-use fugit::ExtU32;
 use hal::gpio::gpioa::PA8;
 use hal::gpio::Alternate;
 use hal::gpio::AF13;
 use hal::hrtim::compare_register::HrCompareRegister;
-use hal::hrtim::event::EventSource;
-use hal::hrtim::external_event::{self, ToExternalEventSource};
-use hal::hrtim::timer_eev_cfg::EevCfgs;
+use hal::hrtim::external_event;
+use hal::hrtim::external_event::ToExternalEventSource;
 use hal::hrtim::timer::HrTimer;
+use hal::hrtim::timer_eev_cfg::EevCfgs;
 use hal::hrtim::HrPwmAdvExt;
 use hal::hrtim::Pscl4;
 use hal::hrtim::{control::HrControltExt, output::HrOutput};
 use hal::prelude::*;
 use hal::pwm;
-use hal::pwr::{self, PwrExt};
+use hal::pwr::PwrExt;
 use hal::rcc;
 use hal::stm32;
 use stm32g4xx_hal as hal;
@@ -29,16 +28,9 @@ use panic_probe as _;
 #[entry]
 fn main() -> ! {
     let dp = stm32::Peripherals::take().expect("cannot take peripherals");
-    let cp = stm32::CorePeripherals::take().expect("cannot take core");
     // Set system frequency to 16MHz * 75/4/2 = 150MHz
     // This would lead to HrTim running at 150MHz * 32 = 4.8GHz...
-    let pwr = dp
-        .PWR
-        .constrain()
-        .vos(pwr::VoltageScale::Range1 {
-            enable_boost: false,
-        })
-        .freeze();
+    let pwr = dp.PWR.constrain().freeze();
 
     let mut rcc = dp.RCC.freeze(
         rcc::Config::pll().pll_cfg(rcc::PllConfig {
@@ -51,8 +43,6 @@ fn main() -> ! {
         pwr,
     );
 
-    let mut delay = cp.SYST.delay(&rcc.clocks);
-
     let gpioa = dp.GPIOA.split(&mut rcc);
     let gpiob = dp.GPIOB.split(&mut rcc);
 
@@ -61,7 +51,7 @@ fn main() -> ! {
 
     let eev_input3 = eev_inputs
         .eev_input3
-        .bind_pin(gpiob.pb7.into_pull_down_input())
+        .bind(gpiob.pb7.into_pull_down_input())
         .edge_or_polarity(external_event::EdgeOrPolarity::Polarity(
             pwm::Polarity::ActiveHigh,
         ))
@@ -101,7 +91,7 @@ fn main() -> ! {
     out1.enable_rst_event(eev_input3);
     out1.enable_set_event(&timer); // Set high at new period
     cr1.set_duty(timer.get_period() / 3);
-    //unsafe {((HRTIM_COMMON::ptr() as *mut u8).offset(0x14) as *mut u32).write_volatile(1); }
+
     out1.enable();
     timer.start(&mut hr_control);