Merge branch 'stm32-rs:main' into flash_patches

Author: amcelroy

.gitignore

@@ -1,4 +1,7 @@
 /target/
 **/*.orig
 **/*.rs.bk
-Cargo.lock
+Cargo.lock
+
+# Remove idea files
+.idea/

Cargo.toml

@@ -9,7 +9,7 @@ license = "MIT/Apache-2.0"
 name = "stm32g4xx-hal"
 readme = "README.md"
 repository = "https://github.com/stm32-rs/stm32g4xx-hal"
-version = "0.0.1"
+version = "0.0.2"
 
 [dependencies]
 nb = "0.1.1"
@@ -18,6 +18,7 @@ paste = "1.0"
 bitflags = "1.2"
 vcell = "0.1"
 static_assertions = "1.1"
+fugit = "0.3.5"
 
 [dependencies.cortex-m]
 version = "0.7.7"
@@ -67,8 +68,6 @@ lazy_static = { version = "1.4", features = ["spin_no_std"] }
 log = "0.4.11"
 cortex-m-log = { version = "0.7", features = ["log-integration"] }
 cfg-if = "0.1.10"
-rtt-target = { version = "0.3.0", features = ["cortex-m"] }
-panic-rtt-target = { version = "0.1.1", features = ["cortex-m"] }
 mpu6050 = "0.1.4"
 bme680 = "0.6.0"
 embedded-sdmmc = "0.3.0"

README.md

@@ -38,7 +38,7 @@ Examples can be built and run using `cargo run`. It is necessary to provide any
 required features followed by the name of the chip. 
 
 ```
-cargo run --example usb_serial --features stm32g473 --features usb_fs --release -- --chip STM32G473RETx
+cargo run --example blinky_delay --features stm32g474,log-rtt,defmt --release -- --chip STM32G474RBTx
 ```
 
 A list of chips supported by probe-rs can be found by running

examples/blinky.rs

@@ -8,11 +8,12 @@ use hal::stm32;
 use stm32g4xx_hal as hal;
 
 use cortex_m_rt::entry;
-use log::info;
 
 #[macro_use]
 mod utils;
 
+use utils::logger::info;
+
 #[entry]
 fn main() -> ! {
     utils::logger::init();
@@ -27,11 +28,12 @@ fn main() -> ! {
 
     loop {
         info!("Set Led low");
-        for _ in 0..100_000 {
+        for _ in 0..10_000_000 {
             led.set_low().unwrap();
         }
+
         info!("Set Led High");
-        for _ in 0..100_000 {
+        for _ in 0..10_000_000 {
             led.set_high().unwrap();
         }
     }

examples/blinky_delay.rs

@@ -7,11 +7,12 @@ use hal::delay::DelayFromCountDownTimer;
 use hal::prelude::*;
 use hal::rcc::Config;
 use hal::stm32;
+use hal::time::ExtU32;
 use hal::timer::Timer;
 use stm32g4xx_hal as hal;
 
 use cortex_m_rt::entry;
-use log::info;
+use utils::logger::info;
 
 #[macro_use]
 mod utils;
@@ -34,13 +35,13 @@ fn main() -> ! {
 
     info!("Init Timer2 delay");
     let timer2 = Timer::new(dp.TIM2, &rcc.clocks);
-    let mut delay_tim2 = DelayFromCountDownTimer::new(timer2.start_count_down(100.ms()));
+    let mut delay_tim2 = DelayFromCountDownTimer::new(timer2.start_count_down(100.millis()));
 
     loop {
         info!("Toggle");
         led.toggle().unwrap();
         info!("SYST delay");
-        delay_syst.delay(1000.ms());
+        delay_syst.delay(1000.millis());
         info!("Toggle");
         led.toggle().unwrap();
         info!("TIM2 delay");

examples/button.rs

@@ -1,8 +1,6 @@
 #![no_main]
 #![no_std]
 
-use panic_rtt_target as _;
-
 use stm32g4xx_hal::{
     //delay::{DelayExt, SYSTDelayExt},
     gpio::{gpioc, ExtiPin, GpioExt, Input, PullDown, SignalEdge},
@@ -18,24 +16,27 @@ use cortex_m::{asm::wfi, interrupt::Mutex};
 use cortex_m_rt::entry;
 use embedded_hal::digital::v2::OutputPin;
 
-use rtt_target::{rprintln, rtt_init_print};
-
 type ButtonPin = gpioc::PC13<Input<PullDown>>;
 
 // Make LED pin globally available
 static G_BUTTON: Mutex<RefCell<Option<ButtonPin>>> = Mutex::new(RefCell::new(None));
 static G_LED_ON: AtomicBool = AtomicBool::new(true);
 
+#[macro_use]
+mod utils;
+
+use utils::logger::println;
+
 // Define an interupt handler, i.e. function to call when interrupt occurs.
 // This specific interrupt will "trip" when the button is pressed
 #[interrupt]
 fn EXTI15_10() {
     static mut BUTTON: Option<ButtonPin> = None;
 
-    rprintln!("Got IRQ!");
+    println!("Got IRQ!");
 
     let button = BUTTON.get_or_insert_with(|| {
-        rprintln!("Transfer Button into EXTI interrupt");
+        println!("Transfer Button into EXTI interrupt");
         cortex_m::interrupt::free(|cs| {
             // Move LED pin here, leaving a None in its place
             G_BUTTON.borrow(cs).replace(None).unwrap()
@@ -49,45 +50,43 @@ fn EXTI15_10() {
 
 #[entry]
 fn main() -> ! {
-    rtt_init_print!();
-
     let mut dp = stm32::Peripherals::take().expect("cannot take peripherals");
     let mut rcc = dp.RCC.constrain();
     let mut syscfg = dp.SYSCFG.constrain();
 
-    rprintln!("Led Init");
+    println!("Led Init");
     // Configure PA5 pin to blink LED
     let gpioa = dp.GPIOA.split(&mut rcc);
     let mut led = gpioa.pa5.into_push_pull_output();
 
-    rprintln!("Button Init");
+    println!("Button Init");
     let gpioc = dp.GPIOC.split(&mut rcc);
     let mut button = gpioc.pc13.into_pull_down_input();
     button.make_interrupt_source(&mut syscfg);
     button.trigger_on_edge(&mut dp.EXTI, SignalEdge::Rising);
     button.enable_interrupt(&mut dp.EXTI);
 
-    rprintln!("Set Button into Global Mutex");
+    println!("Set Button into Global Mutex");
     // Move the pin into our global storage
     cortex_m::interrupt::free(|cs| *G_BUTTON.borrow(cs).borrow_mut() = Some(button));
 
-    rprintln!("Enable EXTI Interrupt");
+    println!("Enable EXTI Interrupt");
     unsafe {
         cortex_m::peripheral::NVIC::unmask(Interrupt::EXTI15_10);
     }
 
     //let mut delay = cp.SYST.delay(&rcc.clocks);
 
-    rprintln!("Start Loop");
+    println!("Start Loop");
     loop {
         wfi();
-        rprintln!("Check");
+        println!("Check");
 
         if G_LED_ON.load(Ordering::Relaxed) {
-            rprintln!("Turn Led On!");
+            println!("Turn Led On!");
             led.set_high().unwrap();
         } else {
-            rprintln!("Turn Led Off!");
+            println!("Turn Led Off!");
             led.set_low().unwrap();
         }
     }

examples/can-echo.rs

@@ -7,7 +7,7 @@ use crate::hal::{
     nb::block,
     rcc::{Config, RccExt, SysClockSrc},
     stm32::Peripherals,
-    time::U32Ext,
+    time::RateExtU32,
 };
 use fdcan::{
     config::NominalBitTiming,
@@ -47,7 +47,7 @@ fn main() -> ! {
     let dp = Peripherals::take().unwrap();
     let _cp = cortex_m::Peripherals::take().expect("cannot take core peripherals");
     let rcc = dp.RCC.constrain();
-    let mut rcc = rcc.freeze(Config::new(SysClockSrc::HSE(24.mhz())));
+    let mut rcc = rcc.freeze(Config::new(SysClockSrc::HSE(24.MHz())));
 
     info!("Split GPIO");
 

examples/hello.rs

@@ -5,15 +5,18 @@
 
 extern crate cortex_m;
 extern crate cortex_m_rt as rt;
-extern crate panic_semihosting;
 extern crate stm32g4xx_hal as hal;
 
-use cortex_m_semihosting::hprintln;
 use rt::entry;
 
+#[macro_use]
+mod utils;
+
+use utils::logger::println;
+
 #[entry]
 fn main() -> ! {
-    hprintln!("Hello, STM32G4!").unwrap();
+    let _ = println!("Hello, STM32G4!");
 
     #[allow(clippy::empty_loop)]
     loop {}

examples/i2c-bme680.rs

@@ -10,6 +10,7 @@ use hal::delay::DelayFromCountDownTimer;
 use hal::i2c::Config;
 use hal::prelude::*;
 use hal::stm32;
+use hal::time::{ExtU32, RateExtU32};
 use hal::timer::Timer;
 use stm32g4xx_hal as hal;
 
@@ -32,11 +33,11 @@ fn main() -> ! {
     let sda = gpiob.pb9.into_alternate_open_drain();
     let scl = gpiob.pb8.into_alternate_open_drain();
 
-    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.khz()), &mut rcc);
+    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.kHz()), &mut rcc);
 
     let mut delayer = cp.SYST.delay(&rcc.clocks);
     let timer2 = Timer::new(dp.TIM2, &rcc.clocks);
-    let mut delay = DelayFromCountDownTimer::new(timer2.start_count_down(100.ms()));
+    let mut delay = DelayFromCountDownTimer::new(timer2.start_count_down(100.millis()));
 
     let mut dev =
         Bme680::init(i2c, &mut delayer, I2CAddress::Secondary).expect("Init function failed");

examples/i2c-mpu6050.rs

@@ -6,6 +6,7 @@
 use hal::i2c::Config;
 use hal::prelude::*;
 use hal::stm32;
+use hal::time::{ExtU32, RateExtU32};
 use stm32g4xx_hal as hal;
 
 use cortex_m_rt::entry;
@@ -28,7 +29,7 @@ fn main() -> ! {
     let sda = gpiob.pb9.into_alternate_open_drain();
     let scl = gpiob.pb8.into_alternate_open_drain();
 
-    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.khz()), &mut rcc);
+    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.kHz()), &mut rcc);
 
     let mut mpu = Mpu6050::new(i2c);
     let mut delay = cp.SYST.delay(&rcc.clocks);
@@ -39,6 +40,6 @@ fn main() -> ! {
         let gyro = mpu.get_gyro().expect("cannot read gyro");
         let temp = mpu.get_temp().expect("cannot read temperature");
         info!("acc: {:?}, gyro: {:?}, temp: {:?}C", acc, gyro, temp);
-        delay.delay(250.ms());
+        delay.delay(250.millis());
     }
 }