First release of stm32f0xx-hal based on stm32f042-hal

Signed-off-by: Daniel Egger <[email protected]>

Author: therealprof

.cargo/config

@@ -0,0 +1,8 @@
+[target.thumbv6m-none-eabi]
+runner = 'arm-none-eabi-gdb'
+rustflags = [
+  "-C", "link-arg=-Tlink.x",
+]
+
+[build]
+target = "thumbv6m-none-eabi"

.gitignore

@@ -0,0 +1,5 @@
+/target/
+**/*.orig
+**/*.rs.bk
+Cargo.lock
+*.txt

Cargo.toml

@@ -0,0 +1,53 @@
+[package]
+authors = ["Daniel Egger <[email protected]>"]
+categories = [
+    "embedded",
+    "hardware-support",
+    "no-std",
+]
+description = "Peripheral access API for STM32F0 series microcontrollers"
+documentation = "https://docs.rs/stm32f0xx-hal"
+keywords = [
+    "arm",
+    "cortex-m",
+    "stm32f0xx",
+    "hal",
+]
+license = "0BSD"
+name = "stm32f0xx-hal"
+readme = "README.md"
+repository = "https://github.com/stm32-rs/stm32f0xx-hal"
+version = "0.7.0"
+
+[dependencies]
+bare-metal = { version = "0.2.4", features = ["const-fn"] }
+cortex-m = "0.5.8"
+cortex-m-rt = "0.6.5"
+nb = "0.1.1"
+void = { version = "1.0.2", default-features = false }
+stm32f0 = "0.4.0"
+
+[dependencies.cast]
+default-features = false
+version = "0.2.2"
+
+[dependencies.embedded-hal]
+features = ["unproven"]
+version = "0.2.2"
+
+[dev-dependencies]
+ina260 = "0.2.3"
+numtoa = "0.2.3"
+panic-halt = "0.2.0"
+
+[features]
+rt = ["stm32f0/rt"]
+stm32f042 = ["stm32f0/stm32f0x2"]
+
+[profile.dev]
+debug = true
+
+[profile.release]
+debug = true
+lto = true
+opt-level = "s"

README.md

@@ -0,0 +1,33 @@
+stm32f0xx-hal
+=============
+
+_stm32f0xx-hal_ contains a hardware abstraction on top of the peripheral access
+API for the STMicro STM32F0xx family of microcontrollers. It replaces the
+[stm32f042-hal][] by a more ubiqitous version suitable for additional families.
+
+Currently supported configuration are:
+* stm32f042
+
+The idea behind this crate is to gloss over the slight differences in the
+various peripherals available on those MCUs so a HAL can be written for all
+chips in that same family without having to cut and paste crates for every
+single model.
+
+Collaboration on this crate is highly welcome as are pull requests!
+
+This crate relies on Adam Greigs fantastic [stm32f0][] crate to provide
+appropriate register definitions and implements a partial set of the
+[embedded-hal][] traits.
+
+Some of the implementation was shamelessly adapted from the [stm32f103xx-hal][]
+crate by Jorge Aparicio.
+
+[stm32f0]: https://crates.io/crates/stm32f0
+[stm32f042-hal]: https://github.com/therealprof/stm32f042-hal
+[stm32f103xx-hal]: https://github.com/japaric/stm32f103xx-hal
+[embedded-hal]: https://github.com/japaric/embedded-hal.git
+
+License
+-------
+
+[0-clause BSD license](LICENSE-0BSD.txt).

examples/blinky.rs

@@ -0,0 +1,37 @@
+#![no_main]
+#![no_std]
+
+extern crate cortex_m_rt;
+extern crate panic_halt;
+
+extern crate stm32f0xx_hal as hal;
+
+use hal::prelude::*;
+use hal::stm32;
+
+use cortex_m_rt::entry;
+
+#[entry]
+fn main() -> ! {
+    if let Some(p) = stm32::Peripherals::take() {
+        let gpioa = p.GPIOA.split();
+
+        /* (Re-)configure PA1 as output */
+        let mut led = gpioa.pa1.into_push_pull_output();
+
+        loop {
+            /* Turn PA1 on a million times in a row */
+            for _ in 0..1_000_000 {
+                led.set_high();
+            }
+            /* Then turn PA1 off a million times in a row */
+            for _ in 0..1_000_000 {
+                led.set_low();
+            }
+        }
+    }
+
+    loop {
+        continue;
+    }
+}

examples/blinky_delay.rs

@@ -0,0 +1,46 @@
+#![no_main]
+#![no_std]
+
+extern crate cortex_m;
+extern crate cortex_m_rt;
+extern crate panic_halt;
+
+extern crate stm32f0xx_hal as hal;
+
+use hal::delay::Delay;
+use hal::prelude::*;
+use hal::stm32;
+
+use cortex_m::peripheral::Peripherals;
+use cortex_m_rt::entry;
+
+#[entry]
+fn main() -> ! {
+    if let (Some(p), Some(cp)) = (stm32::Peripherals::take(), Peripherals::take()) {
+        let gpioa = p.GPIOA.split();
+
+        /* (Re-)configure PA1 as output */
+        let mut led = gpioa.pa1.into_push_pull_output();
+
+        /* Constrain clocking registers */
+        let mut rcc = p.RCC.constrain();
+
+        /* Configure clock to 8 MHz (i.e. the default) and freeze it */
+        let clocks = rcc.cfgr.sysclk(8.mhz()).freeze();
+
+        /* Get delay provider */
+        let mut delay = Delay::new(cp.SYST, clocks);
+
+        loop {
+            led.set_high();
+            delay.delay_ms(1_000_u16);
+
+            led.set_low();
+            delay.delay_ms(1_000_u16);
+        }
+    }
+
+    loop {
+        continue;
+    }
+}

examples/flash_systick.rs

@@ -0,0 +1,86 @@
+#![no_main]
+#![no_std]
+
+extern crate cortex_m;
+extern crate cortex_m_rt;
+extern crate panic_halt;
+
+extern crate stm32f0xx_hal as hal;
+
+use hal::gpio::*;
+use hal::prelude::*;
+use hal::stm32;
+
+use cortex_m::interrupt::Mutex;
+use cortex_m::peripheral::syst::SystClkSource::Core;
+use cortex_m::peripheral::Peripherals;
+use cortex_m_rt::{entry, exception};
+
+use core::cell::RefCell;
+use core::ops::DerefMut;
+
+static GPIO: Mutex<RefCell<Option<gpioa::PA1<Output<PushPull>>>>> = Mutex::new(RefCell::new(None));
+
+#[entry]
+fn main() -> ! {
+    if let (Some(p), Some(cp)) = (stm32::Peripherals::take(), Peripherals::take()) {
+        let gpioa = p.GPIOA.split();
+        let mut rcc = p.RCC.constrain();
+        let _ = rcc.cfgr.sysclk(48.mhz()).freeze();
+        let mut syst = cp.SYST;
+
+        /* (Re-)configure PA1 as output */
+        let mut led = gpioa.pa1.into_push_pull_output();
+
+        cortex_m::interrupt::free(move |cs| {
+            *GPIO.borrow(cs).borrow_mut() = Some(led);
+        });
+
+        /* Initialise SysTick counter with a defined value */
+        unsafe { syst.cvr.write(1) };
+
+        /* Set source for SysTick counter, here full operating frequency (== 8MHz) */
+        syst.set_clock_source(Core);
+
+        /* Set reload value, i.e. timer delay 48 MHz/4 Mcounts == 12Hz or 83ms */
+        syst.set_reload(4_000_000 - 1);
+
+        /* Start counter */
+        syst.enable_counter();
+
+        /* Start interrupt generation */
+        syst.enable_interrupt();
+    }
+
+    loop {
+        continue;
+    }
+}
+
+/* Define an exception, i.e. function to call when exception occurs. Here if our SysTick timer
+ * trips the flash function will be called and the specified stated passed in via argument */
+//, flash, state: u8 = 1);
+#[exception]
+fn SysTick() -> ! {
+    static mut state: u8 = 1;
+
+    /* Enter critical section */
+    cortex_m::interrupt::free(|cs| {
+        if let Some(ref mut led) = *GPIO.borrow(cs).borrow_mut().deref_mut() {
+            /* Check state variable, keep LED off most of the time and turn it on every 10th tick */
+            if *state < 10 {
+                /* If set turn off the LED */
+                led.set_low();
+
+                /* And now increment state variable */
+                *state += 1;
+            } else {
+                /* If not set, turn on the LED */
+                led.set_high();
+
+                /* And set new state variable back to 0 */
+                *state = 0;
+            }
+        }
+    });
+}