Add v1.0 L4 heartbeat example

Author: barafael

rtic_v1/stm32l4_heartbeat/.cargo/config

@@ -0,0 +1,33 @@
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+# uncomment ONE of these three option to make `cargo run` start a GDB session
+# which option to pick depends on your system
+# runner = "arm-none-eabi-gdb -q -x jlink.gdb"
+# runner = "arm-none-eabi-gdb -q -x openocd.gdb"
+runner = "gdb-multiarch -q -x openocd.gdb"
+# runner = "gdb -q -x openocd.gdb"
+
+rustflags = [
+  # LLD (shipped with the Rust toolchain) is used as the default linker
+  "-C", "link-arg=-Tlink.x",
+
+  # if you run into problems with LLD switch to the GNU linker by commenting out
+  # this line
+  # "-C", "linker=arm-none-eabi-ld",
+
+  # if you need to link to pre-compiled C libraries provided by a C toolchain
+  # use GCC as the linker by commenting out both lines above and then
+  # uncommenting the three lines below
+  # "-C", "linker=arm-none-eabi-gcc",
+  # "-C", "link-arg=-Wl,-Tlink.x",
+  # "-C", "link-arg=-nostartfiles",
+
+  # uncomment for unchecked wrapping arithmetics also in dev mode
+  # "-Z", "force-overflow-checks=off",
+]
+
+[build]
+# Pick ONE of these compilation targets
+# target = "thumbv6m-none-eabi"    # Cortex-M0 and Cortex-M0+
+# target = "thumbv7m-none-eabi"    # Cortex-M3
+# target = "thumbv7em-none-eabi"   # Cortex-M4 and Cortex-M7 (no FPU)
+target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)

rtic_v1/stm32l4_heartbeat/.embed.toml

@@ -0,0 +1,16 @@
+# Refer to https://github.com/probe-rs/cargo-embed/blob/master/src/config/default.toml
+# for the comprehensive list of options
+
+[default.general]
+chip = "STM32L412"
+
+[default.rtt]
+enabled = true
+show_timestamps = true
+
+[default.gdb]
+# Whether or not a GDB server should be opened after flashing.
+# This is exclusive and cannot be used with RTT at the moment.
+enabled = false
+# The connection string in host:port format wher the GDB server will open a socket.
+# gdb_connection_string

rtic_v1/stm32l4_heartbeat/.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

rtic_v1/stm32l4_heartbeat/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "stm32l4_heartbeat"
+categories = ["embedded", "no-std"]
+authors = [
+    "arrowcircle",
+    "Emil Fresk <emil.fresk@gmail.com>",
+    "Domenico Andreoli <domenico.andreoli@linux.com>",
+]
+description = "Heartbeat for stm32l4xx"
+keywords = ["arm", "cortex-m"]
+license = "MIT OR Apache-2.0"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+embedded-hal = "0.2.6"
+cortex-m-rtic = "1.0.0"
+stm32l4xx-hal = { version = "0.6.0", features = ["rt", "stm32l4x2"] }
+heapless = "0.7.10"
+systick-monotonic = "1.0.0"
+panic-rtt-target = { version = "0.1.2", features = ["cortex-m"] }
+rtt-target = { version = "0.3.1", features = ["cortex-m"] }
+
+# this lets you use `cargo fix`!
+[[bin]]
+name = "stm32l4_heartbeat"
+test = false
+bench = false
+
+[profile.dev]
+opt-level = 1
+codegen-units = 16
+debug = true
+lto = false
+
+[profile.release]
+opt-level = "s"   # optimize for size
+codegen-units = 1 # better optimizations
+debug = true      # symbols are nice and they don't increase the size on Flash
+lto = true        # better optimizations

rtic_v1/stm32l4_heartbeat/memory.x

@@ -0,0 +1,8 @@
+MEMORY
+{
+  /* NOTE 1 K = 1 KiBi = 1024 bytes */
+  /* TODO Adjust these memory regions to match your device memory layout */
+  /* These values correspond to the LM3S6965, one of the few devices QEMU can emulate */
+  FLASH : ORIGIN = 0x08000000, LENGTH = 64K
+  RAM : ORIGIN = 0x20000000, LENGTH = 20K
+}

rtic_v1/stm32l4_heartbeat/src/main.rs

@@ -0,0 +1,91 @@
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![no_main]
+#![no_std]
+
+use heapless::Vec;
+use panic_rtt_target as _;
+use rtic::app;
+use rtt_target::{rprintln, rtt_init_print};
+use stm32l4xx_hal::gpio::{gpiob::PB3, Output, PushPull, State};
+use stm32l4xx_hal::prelude::*;
+use systick_monotonic::{fugit::Duration, Systick};
+
+#[app(device = stm32l4xx_hal::pac, dispatchers = [SPI3])]
+mod app {
+    use super::*;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        led: PB3<Output<PushPull>>,
+        intervals: Vec<u32, 6>,
+    }
+
+    #[monotonic(binds = SysTick, default = true)]
+    type MonoTimer = Systick<1000>;
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
+        // Setup clocks
+        let mut flash = cx.device.FLASH.constrain();
+        let mut rcc = cx.device.RCC.constrain();
+        let mut pwr = cx.device.PWR.constrain(&mut rcc.apb1r1);
+        let mono = Systick::new(cx.core.SYST, 72_000_000);
+
+        rtt_init_print!();
+        rprintln!("init");
+
+        let _clocks = rcc.cfgr.sysclk(72.mhz()).freeze(&mut flash.acr, &mut pwr);
+
+        // Setup LED
+        let mut gpiob = cx.device.GPIOB.split(&mut rcc.ahb2);
+        let led = gpiob.pb3.into_push_pull_output_with_state(
+            &mut gpiob.moder,
+            &mut gpiob.otyper,
+            State::Low,
+        );
+
+        // Simple heart beat LED on/off sequence
+        let mut intervals: Vec<u32, 6> = Vec::new();
+        intervals.push(30).unwrap(); // P Wave
+        intervals.push(40).unwrap(); // PR Segment
+        intervals.push(120).unwrap(); // QRS Complex
+        intervals.push(30).unwrap(); // ST Segment
+        intervals.push(60).unwrap(); // T Wave
+        intervals.push(720).unwrap(); // Rest
+
+        // Schedule the blinking task
+        blink::spawn(0).unwrap();
+
+        (Shared {}, Local { led, intervals }, init::Monotonics(mono))
+    }
+
+    #[idle]
+    fn idle(_: idle::Context) -> ! {
+        loop {
+            core::hint::spin_loop();
+        }
+    }
+
+    #[task(local = [led, intervals])]
+    fn blink(cx: blink::Context, state: usize) {
+        rprintln!("blink");
+        let duration = cx.local.intervals[state];
+        let next_state = (state + 1) % cx.local.intervals.len();
+
+        if state % 2 == 0 {
+            cx.local.led.set_high().unwrap();
+        } else {
+            cx.local.led.set_low().unwrap();
+        }
+
+        blink::spawn_after(
+            Duration::<u64, 1, 1000>::from_ticks(duration as u64),
+            next_state,
+        )
+        .unwrap();
+    }
+}