Update examples for new hal

Author: usbalbin

examples/stm32g4/.cargo/config.toml

@@ -0,0 +1,9 @@
+[target.thumbv7em-none-eabihf]
+runner = 'probe-rs run --connect-under-reset'
+rustflags = [
+  "-C", "link-arg=-Tlink.x",
+  "-C", "link-arg=-Tdefmt.x",
+]
+
+[build]
+target = "thumbv7em-none-eabihf"

examples/stm32g4/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "rust-analyzer.check.allTargets": false,
+  "rust-analyzer.check.extraArgs": [
+    "--bins"
+  ],
+  "rust-analyzer.cargo.target": "thumbv7em-none-eabihf",
+  "rust-analyzer.cargo.features": ["stm32g474"]
+}

examples/stm32g4/src/bin/adc-trigger.rs

@@ -11,9 +11,9 @@ use stm32_hrtim::{
     timer::HrTimer,
 };
 use stm32g4xx_hal::{
-    adc::{self, AdcClaim, ClockSource, Temperature, Vref},
+    adc::{self, temperature::Temperature, AdcClaim, AdcCommonExt, Vref},
     delay::SYSTDelayExt,
-    dma::{self, TransferExt, channel::DMAExt, config::DmaConfig},
+    dma::{self, channel::DMAExt, config::DmaConfig, TransferExt},
     gpio::GpioExt,
     hrtim::{HrControltExt, HrPwmBuilderExt},
     pwr::PwrExt,
@@ -105,15 +105,16 @@ fn main() -> ! {
     out2.enable_set_event(&timer);
 
     defmt::info!("Setup Adc1");
-    let mut adc = dp
-        .ADC1
-        .claim(ClockSource::SystemClock, &rcc, &mut delay, true);
+    let mut adc12_common = dp
+        .ADC12_COMMON
+        .claim(adc::config::ClockMode::AdcHclkDiv4, &mut rcc);
+    let mut adc = adc12_common.claim(dp.ADC1, &mut delay);
 
     adc.set_external_trigger((
         adc::config::TriggerMode::RisingEdge,
         (&hr_control.adc_trigger1).into(),
     ));
-    adc.enable_temperature(&dp.ADC12_COMMON);
+    adc12_common.enable_temperature();
     adc.set_continuous(adc::config::Continuous::Discontinuous);
     adc.reset_sequence();
     adc.configure_channel(

examples/stm32g4/src/bin/eev-comp.rs

@@ -16,14 +16,7 @@ use stm32_hrtim::{
     timer_eev_cfg::{EevCfg, EevCfgs},
 };
 use stm32g4xx_hal::{
-    comparator::{self, ComparatorExt, ComparatorSplit},
-    dac::{self, DacExt, DacOut},
-    delay::SYSTDelayExt,
-    gpio::{GpioExt, SignalEdge},
-    hrtim::{HrControltExt, HrPwmBuilderExt, external_event::EevInputExt},
-    pwr::PwrExt,
-    rcc::{self, RccExt},
-    stm32::{CorePeripherals, Peripherals},
+    comparator::{self, ComparatorExt, ComparatorSplit}, dac::{self, DacExt, DacOut}, delay::SYSTDelayExt, gpio::{GpioExt, SignalEdge}, hrtim::{external_event::EevInputExt, HrControltExt, HrPwmBuilderExt}, pwr::PwrExt, rcc::{self, RccExt}, stasis::Freeze, stm32::{CorePeripherals, Peripherals}
 };
 
 #[entry]
@@ -55,7 +48,7 @@ fn main() -> ! {
     let pin_a = gpioa.pa8;
 
     let dac1ch1 = dp.DAC1.constrain(dac::Dac1IntSig1, &mut rcc);
-    let mut dac = dac1ch1.calibrate_buffer(&mut delay).enable(&mut rcc);
+    let (mut dac, [dac_token]) = dac1ch1.calibrate_buffer(&mut delay).enable(&mut rcc).freeze();
 
     // Use dac to define the fault threshold
     // 2^12 / 2 = 2^11 for about half of VCC
@@ -65,8 +58,8 @@ fn main() -> ! {
     let (comp1, ..) = dp.COMP.split(&mut rcc);
 
     let comp1 = comp1.comparator(
-        &input,
-        &dac,
+        input,
+        dac_token,
         comparator::Config::default().hysteresis(comparator::Hysteresis::None),
         //.output_inverted(),
         &rcc.clocks,

examples/stm32g4/src/bin/flt-comp.rs

@@ -16,16 +16,7 @@ use stm32_hrtim::{
     timer::HrTimer,
 };
 use stm32g4xx_hal::{
-    self as hal,
-    adc::AdcClaim,
-    comparator::{self, ComparatorExt, ComparatorSplit},
-    dac::{Dac3IntSig1, DacExt, DacOut},
-    delay::{DelayExt as _, SYSTDelayExt},
-    gpio::GpioExt,
-    hrtim::{HrControltExt, HrPwmBuilderExt, fault::FaultInput},
-    pwr::PwrExt,
-    rcc::{self, RccExt},
-    stm32::{CorePeripherals, Peripherals},
+    self as hal, adc::{config::ClockMode, AdcClaim, AdcCommonExt}, comparator::{self, ComparatorExt, ComparatorSplit}, dac::{Dac3IntSig1, DacExt, DacOut}, delay::{DelayExt as _, SYSTDelayExt}, gpio::GpioExt, hrtim::{fault::FaultInput, HrControltExt, HrPwmBuilderExt}, pwr::PwrExt, rcc::{self, RccExt}, stasis::Freeze, stm32::{CorePeripherals, Peripherals}
 };
 
 #[entry]
@@ -48,20 +39,14 @@ fn main() -> ! {
 
     let mut delay = cp.SYST.delay(&rcc.clocks);
 
-    let mut adc1 = dp.ADC1.claim_and_configure(
-        hal::adc::ClockSource::SystemClock,
-        &rcc,
-        hal::adc::config::AdcConfig::default()
-            .clock_mode(hal::adc::config::ClockMode::Synchronous_Div_4),
-        &mut delay,
-        false,
-    );
+    let adc12_common = dp.ADC12_COMMON.claim(ClockMode::AdcHclkDiv4, &mut rcc);
+    let mut adc1 = adc12_common.claim_and_configure(dp.ADC1, Default::default(), &mut delay);
 
     let gpioa = dp.GPIOA.split(&mut rcc);
     let gpioc = dp.GPIOC.split(&mut rcc);
 
     let dac3ch1 = dp.DAC3.constrain(Dac3IntSig1, &mut rcc);
-    let mut dac = dac3ch1.enable(&mut rcc);
+    let (mut dac, [dac_token]) = dac3ch1.enable(&mut rcc).freeze();
 
     // Use dac to define the fault threshold
     // 2^12 / 2 = 2^11 for about half of VCC
@@ -70,11 +55,11 @@ fn main() -> ! {
 
     let (_comp1, _comp2, comp3, ..) = dp.COMP.split(&mut rcc);
 
-    let pc1 = gpioc.pc1.into_analog();
+    let (pc1, [pc1_token]) = gpioc.pc1.into_analog().freeze();
     let comp3 = comp3
         .comparator(
-            &pc1,
-            &dac,
+            pc1_token,
+            dac_token,
             comparator::Config::default()
                 .hysteresis(comparator::Hysteresis::None)
                 .output_inverted(),