fix examples

Author: burrbull

examples/adc_ext_trig_double_dma_serial.rs

@@ -63,7 +63,7 @@ unsafe fn DMA_CHANNEL1() {
     // Address is in byte, value in 2Bytes, this is why second dma buffer ist added with BUFFER_SIZE
     // and not BUFFER_SIZE/2
 
-    let dma = &(*stm32g0::stm32g031::DMA::ptr());
+    let dma = &(*hal::stm32::DMA::ptr());
     let htif1 = dma.isr.read().htif1().bit();
     let tcif1 = dma.isr.read().tcif1().bit();
     // set the global clear bit of DMA channel1
@@ -107,7 +107,7 @@ fn main() -> ! {
 
     let mut dma = dp.DMA.split(&mut rcc, dp.DMAMUX);
 
-    let adc_ptr = unsafe { &(*stm32g0::stm32g031::ADC::ptr()) };
+    let adc_ptr = unsafe { &(*hal::stm32::ADC::ptr()) };
     let adc_data_register_addr = &adc_ptr.dr as *const _ as u32;
 
     let adc_buffer1_addr: u32 = adc_buffer1.as_ptr() as u32;
@@ -125,8 +125,7 @@ fn main() -> ! {
                                                                          // https://sourceware.org/gdb/current/onlinedocs/gdb/Memory.html
 
     // dma ch1 reads from ADC register into memory
-    dma.ch1
-        .select_peripheral(stm32g0xx_hal::dmamux::DmaMuxIndex::ADC);
+    dma.ch1.select_peripheral(hal::dmamux::DmaMuxIndex::ADC);
     // The dma continuesly fills the buffer, when its full, it starts over again
     dma.ch1.set_circular_mode(true);
 
@@ -180,7 +179,7 @@ fn main() -> ! {
     // this is only available on timer TIM2, TIM3, TIM4 and TIM1
     unsafe {
         // get pointer of timer 2
-        let tim = &(*stm32g0::stm32g031::TIM2::ptr());
+        let tim = &(*hal::stm32::TIM2::ptr());
         //
         tim.cr2.modify(|_, w| w.mms().bits(3 as u8));
     }

examples/ir_remote.rs

@@ -20,7 +20,7 @@ use infrared::protocols::nec::NecCommand;
 use infrared::{protocols::Nec, Sender};
 use rtic::app;
 
-const IR_SAMPLERATE: Hertz = Hertz(20_000);
+const IR_SAMPLERATE: Hertz = Hertz::kHz(20);
 const STROBE_COMMAND: NecCommand = NecCommand {
     addr: 0,
     cmd: 15,
@@ -31,15 +31,22 @@ type IrPin = PwmPin<stm32::TIM17, timer::Channel1>;
 type IrTimer = Timer<stm32::TIM16>;
 
 #[app(device = hal::stm32, peripherals = true)]
-const APP: () = {
-    struct Resources {
-        timer: IrTimer,
+mod app {
+    use super::*;
+
+    #[shared]
+    struct Shared {
         transmitter: Sender<Nec, IrPin>,
+    }
+
+    #[local]
+    struct Local {
+        timer: IrTimer,
         exti: stm32::EXTI,
     }
 
     #[init]
-    fn init(mut ctx: init::Context) -> init::LateResources {
+    fn init(mut ctx: init::Context) -> (Shared, Local, init::Monotonics) {
         let mut rcc = ctx.device.RCC.freeze(rcc::Config::pll());
 
         let gpiob = ctx.device.GPIOB.split(&mut rcc);
@@ -48,33 +55,35 @@ const APP: () = {
         gpioc.pc13.listen(SignalEdge::Falling, &mut ctx.device.EXTI);
 
         let mut timer = ctx.device.TIM16.timer(&mut rcc);
-        timer.start(IR_SAMPLERATE);
+        timer.start(IR_SAMPLERATE.into_duration());
         timer.listen();
 
         let carrier_timer = ctx.device.TIM17.pwm(38.kHz(), &mut rcc);
         let mut ir_pin = carrier_timer.bind_pin(gpiob.pb9);
         ir_pin.set_duty(ir_pin.get_max_duty() / 2);
-        let transmitter = Sender::new(IR_SAMPLERATE.0, ir_pin);
+        let transmitter = Sender::new(IR_SAMPLERATE.raw(), ir_pin);
 
-        init::LateResources {
-            timer,
-            transmitter,
-            exti: ctx.device.EXTI,
-        }
+        (
+            Shared { transmitter },
+            Local {
+                timer,
+                exti: ctx.device.EXTI,
+            },
+            init::Monotonics(),
+        )
     }
 
-    #[task(binds = TIM16, resources = [timer, transmitter])]
-    fn timer_tick(ctx: timer_tick::Context) {
-        ctx.resources.transmitter.tick();
-        ctx.resources.timer.clear_irq();
+    #[task(binds = TIM16, local = [timer], shared = [transmitter])]
+    fn timer_tick(mut ctx: timer_tick::Context) {
+        ctx.shared.transmitter.lock(|tx| tx.tick());
+        ctx.local.timer.clear_irq();
     }
 
-    #[task(binds = EXTI4_15, resources = [exti, transmitter])]
-    fn button_click(ctx: button_click::Context) {
-        ctx.resources
+    #[task(binds = EXTI4_15, local = [exti], shared = [transmitter])]
+    fn button_click(mut ctx: button_click::Context) {
+        ctx.shared
             .transmitter
-            .load(&STROBE_COMMAND)
-            .expect("failed to send IR command");
-        ctx.resources.exti.unpend(Event::GPIO13);
+            .lock(|tx| tx.load(&STROBE_COMMAND).expect("failed to send IR command"));
+        ctx.local.exti.unpend(Event::GPIO13);
     }
-};
+}

examples/opm.rs

@@ -18,15 +18,21 @@ use hal::timer::opm::Opm;
 use rtic::app;
 
 #[app(device = hal::stm32, peripherals = true)]
-const APP: () = {
-    struct Resources {
+mod app {
+    use super::*;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
         exti: stm32::EXTI,
         led: PA5<Output<PushPull>>,
         opm: Opm<stm32::TIM3>,
     }
 
     #[init]
-    fn init(ctx: init::Context) -> init::LateResources {
+    fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
         let mut rcc = ctx.device.RCC.freeze(rcc::Config::pll());
         let mut exti = ctx.device.EXTI;
 
@@ -55,13 +61,13 @@ const APP: () = {
         opm_ch3.enable();
         opm_ch4.enable();
 
-        init::LateResources { opm, exti, led }
+        (Shared {}, Local { opm, exti, led }, init::Monotonics())
     }
 
-    #[task(binds = EXTI4_15, resources = [exti, led, opm])]
+    #[task(binds = EXTI4_15, local = [exti, led, opm])]
     fn button_click(ctx: button_click::Context) {
-        ctx.resources.led.toggle().unwrap();
-        ctx.resources.opm.generate();
-        ctx.resources.exti.unpend(Event::GPIO13);
+        ctx.local.led.toggle().unwrap();
+        ctx.local.opm.generate();
+        ctx.local.exti.unpend(Event::GPIO13);
     }
-};
+}

examples/rtic.rs

@@ -40,7 +40,7 @@ mod app {
         let gpioc = ctx.device.GPIOC.split(&mut rcc);
 
         let mut timer = ctx.device.TIM17.timer(&mut rcc);
-        timer.start(3.Hz());
+        timer.start(Hertz::Hz(3).into_duration());
         timer.listen();
 
         let mut exti = ctx.device.EXTI;

examples/stopwatch.rs

@@ -34,22 +34,22 @@ fn main() -> ! {
     let elapsed_us = stopwatch.trace(|| {
         delay.delay(100.micros());
     });
-    hprintln!("Delay: 100 us -> {} us", elapsed_us.0).unwrap();
+    hprintln!("Delay: 100 us -> {}", elapsed_us).unwrap();
 
     timer.start(100.micros());
     let elapsed_us = stopwatch.trace(|| {
         block!(timer.wait()).unwrap();
     });
-    hprintln!("Timer: 100 us -> {} us", elapsed_us.0).unwrap();
+    hprintln!("Timer: 100 us -> {}", elapsed_us).unwrap();
 
     let elapsed_us = stopwatch.trace(calc_something);
-    hprintln!("Calc @ 16 MHz: {} us", elapsed_us.0).unwrap();
+    hprintln!("Calc @ 16 MHz: {}", elapsed_us).unwrap();
 
     let rcc = rcc.freeze(Config::new(SysClockSrc::PLL));
     stopwatch.set_clock(rcc.clocks.apb_tim_clk);
 
     let elapsed_us = stopwatch.trace(calc_something);
-    hprintln!("Calc @ 64 MHz: {} us", elapsed_us.0).unwrap();
+    hprintln!("Calc @ 64 MHz: {}", elapsed_us).unwrap();
 
     loop {}
 }

examples/uart-dma.rs

@@ -19,7 +19,6 @@ fn main() -> ! {
     let dp = stm32::Peripherals::take().expect("cannot take peripherals");
     let mut rcc = dp.RCC.constrain();
     let gpioa = dp.GPIOA.split(&mut rcc);
-    let gpiob = dp.GPIOB.split(&mut rcc);
 
     let mut led = gpioa.pa5.into_push_pull_output();
 

src/analog/comparator.rs

@@ -258,7 +258,7 @@ macro_rules! impl_comparator {
                 positive_input.setup(&self);
                 negative_input.setup(&self);
                 // Delay for scaler voltage bridge initialization for certain negative inputs
-                let voltage_scaler_delay = clocks.sys_clk.0 / (1_000_000 / 200); // 200us
+                let voltage_scaler_delay = clocks.sys_clk.raw() / (1_000_000 / 200); // 200us
                 cortex_m::asm::delay(voltage_scaler_delay);
                 self.csr().modify(|_, w| unsafe {
                     w.hyst()

src/lib.rs

@@ -16,6 +16,9 @@ pub extern crate stm32g0;
 
 pub use nb::block;
 
+#[cfg(feature = "device-selected")]
+pub use stm32 as pac;
+
 #[cfg(feature = "stm32g030")]
 pub use stm32g0::stm32g030 as stm32;