[skip ci] start work on blinky example

Author: olback

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "rust-analyzer.cargo.features": [
+        "rt",
+        "stm32h503"
+    ],
+    "rust-analyzer.check.allTargets": false,
+    "rust-analyzer.check.targets": "thumbv8m.main-none-eabihf",
+}

Cargo.toml

@@ -35,10 +35,23 @@ log-semihost = []
 
 [dependencies]
 cortex-m = { version = "^0.7.7", features = ["critical-section-single-core"] }
-stm32h5 = "*"
+stm32h5 = { version = "*", git = "https://github.com/stm32-rs/stm32-rs-nightlies" }
 fugit = "0.3.6"
 embedded-hal = { version = "0.2.7", features = ["unproven"] }
 
+[dev-dependencies]
+cortex-m-rt = ">=0.6.15,<0.8"
+log = "0.4.11"
+panic-halt = "0.2.0"
+panic-rtt-target = { version = "0.1.0", features = ["cortex-m"] }
+cfg-if = "1.0.0"
+rtt-target = "0.4.0"
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+cortex-m-log = { version = "0.8.0", features = ["itm", "semihosting", "log-integration"] }
+cortex-m-semihosting = "0.5.0"
+panic-itm = { version = "~0.4.1" }
+panic-semihosting = "0.6"
+
 [profile.release]
 codegen-units = 1 # better optimizations
 debug = true # symbols are nice and they don't increase the size in flash

NOTES.md

@@ -0,0 +1,9 @@
+# Dev notes
+
+* CubeIDE recomends user to enable the `ICACHE` for maximum perfomance.
+* OpenOCD does not yet support the H5, [ST maintains a fork with support](https://github.com/STMicroelectronics/OpenOCD).
+* OpenOCD does not come with udev rules for the new ST-Link V3, here's the required line:
+```
+# STLink v3
+ATTRS{idVendor}=="0483", ATTRS{idProduct}=="374e", MODE="660", GROUP="plugdev", TAG+="uaccess"
+```

examples/blinky.rs

@@ -0,0 +1,33 @@
+#![no_main]
+#![no_std]
+
+mod utilities;
+
+use cortex_m_rt::entry;
+use stm32h5xx_hal::pac;
+
+#[entry]
+fn main() -> ! {
+    utilities::logger::init();
+
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    // TODO: Power/clock config is required before blinky can... blink.
+
+    dp.GPIOA.moder.write(|w| w.mode5().variant(1)); // output
+    dp.GPIOA.pupdr.write(|w| w.pupd5().variant(1)); // pull-up
+
+    // dp.GPIOA.odr.write(|w| w.od5().set_bit());
+
+    loop {
+        dp.GPIOA.odr.write(|w| w.od5().clear_bit());
+        for _ in 0..1_000_0 {
+            cortex_m::asm::nop();
+        }
+        dp.GPIOA.odr.write(|w| w.od5().set_bit());
+        for _ in 0..1_000_0 {
+            cortex_m::asm::nop();
+        }
+    }
+}

examples/utilities/logger.rs

@@ -0,0 +1,94 @@
+#![cfg_attr(feature = "log-itm", allow(unsafe_code))]
+
+cfg_if::cfg_if! {
+    if #[cfg(any(feature = "log-itm"))] {
+        use panic_itm as _;
+
+        use lazy_static::lazy_static;
+        use log::LevelFilter;
+
+        pub use cortex_m_log::log::Logger;
+
+        use cortex_m_log::{
+            destination::Itm as ItmDest,
+            printer::itm::InterruptSync,
+            modes::InterruptFree,
+            printer::itm::ItmSync
+        };
+
+        lazy_static! {
+            static ref LOGGER: Logger<ItmSync<InterruptFree>> = Logger {
+                level: LevelFilter::Info,
+                inner: unsafe {
+                    InterruptSync::new(
+                        ItmDest::new(cortex_m::Peripherals::steal().ITM)
+                    )
+                },
+            };
+        }
+
+        pub fn init() {
+            cortex_m_log::log::init(&LOGGER).unwrap();
+        }
+
+    }
+    else if #[cfg(any(feature = "log-rtt"))] {
+        use panic_rtt_target as _;
+
+        use log::{Level, Metadata, Record, LevelFilter};
+        use rtt_target::{rprintln, rtt_init_print};
+
+        pub struct Logger {
+            level: Level,
+        }
+
+        static LOGGER: Logger = Logger {
+            level: Level::Info,
+        };
+
+        pub fn init() {
+            rtt_init_print!();
+            log::set_logger(&LOGGER).map(|()| log::set_max_level(LevelFilter::Info)).unwrap();
+        }
+
+        impl log::Log for Logger {
+            fn enabled(&self, metadata: &Metadata) -> bool {
+                metadata.level() <= self.level
+
+            }
+
+            fn log(&self, record: &Record) {
+                rprintln!("{} - {}", record.level(), record.args());
+            }
+
+            fn flush(&self) {}
+        }
+    }
+    else if #[cfg(any(feature = "log-semihost"))] {
+        use panic_semihosting as _;
+
+        use lazy_static::lazy_static;
+        use log::LevelFilter;
+
+        pub use cortex_m_log::log::Logger;
+        use cortex_m_log::printer::semihosting;
+        use cortex_m_log::printer::semihosting::Semihosting;
+        use cortex_m_log::modes::InterruptOk;
+        use cortex_m_semihosting::hio::HostStream;
+
+        lazy_static! {
+            static ref LOGGER: Logger<Semihosting<InterruptOk, HostStream>> = Logger {
+                level: LevelFilter::Info,
+                inner: semihosting::InterruptOk::<_>::stdout().expect("Get Semihosting stdout"),
+            };
+        }
+
+        pub fn init() {
+            cortex_m_log::log::init(&LOGGER).unwrap();
+        }
+    }
+    else {
+        use panic_halt as _;
+        pub fn init() {}
+    }
+}

examples/utilities/mod.rs

@@ -0,0 +1,5 @@
+//! Utilities for examples
+
+pub mod logger;
+#[macro_use]
+mod power;

examples/utilities/power.rs

@@ -0,0 +1,15 @@
+//! Power Configuration for examples
+
+macro_rules! example_power {
+    ($pwr:ident) => {{
+        cfg_if::cfg_if! {
+            if #[cfg(all(feature = "smps", feature = "example-smps"))] {
+                $pwr.smps()
+            } else if #[cfg(all(feature = "smps", feature = "example-ldo"))] {
+                $pwr.ldo()
+            } else {
+                $pwr
+            }
+        }
+    }};
+}

memory/503.x renamed to memory.x

@@ -11,3 +11,26 @@ compile_error!(
         stm32h573
 "
 );
+
+#[cfg(all(feature = "rm0492", feature = "rm0481"))]
+compile_error!("Cannot not select both rm0492 and rm0481");
+
+#[cfg(feature = "stm32h503")]
+pub use stm32h5::stm32h503 as stm32;
+
+#[cfg(any(
+    feature = "stm32h562",
+    feature = "stm32h563",
+    feature = "stm32h573",
+))]
+pub use stm32h5::stm32h573 as stm32;
+
+#[cfg(feature = "device-selected")]
+pub use crate::stm32 as pac;
+#[cfg(feature = "device-selected")]
+pub use crate::stm32 as device;
+
+// Enable use of interrupt macro
+#[cfg(feature = "rt")]
+#[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
+pub use crate::stm32::interrupt;