Add stm32l0-monotonic example for RTIC v1.0

ported from rtic_v0.5/stm32l0_monotonic.

Author: barafael

rtic_v1/stm32l0_monotonic/.cargo/config

@@ -0,0 +1,37 @@
+[target.thumbv7m-none-eabi]
+# uncomment this to make `cargo run` execute programs on QEMU
+# runner = "qemu-system-arm -cpu cortex-m3 -machine lm3s6965evb -nographic -semihosting-config enable=on,target=native -kernel"
+
+[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/stm32l0_monotonic/.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 = "STM32L071"
+
+[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/stm32l0_monotonic/.gitignore

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

rtic_v1/stm32l0_monotonic/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "stm32l0_monotonic"
+categories = ["embedded", "no-std"]
+authors = ["Danilo Bargen <mail@dbrgn.ch>"]
+description = "Example Monotonic trait"
+keywords = ["arm", "cortex-m"]
+license = "MIT OR Apache-2.0"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+cortex-m-rtic = "1.0.0"
+embedded-time = "0.12.1"
+panic-rtt-target = { version = "0.1.2", features = ["cortex-m"] }
+rtt-target = { version = "0.3.1", features = ["cortex-m"] }
+stm32l0xx-hal = { version = "0.9.0", features = ["rt", "mcu-STM32L031K6Tx"] }
+
+# this lets you use `cargo fix`!
+[[bin]]
+name = "stm32l0_monotonic"
+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/stm32l0_monotonic/README.md

@@ -0,0 +1,15 @@
+# STM32L0 Monotonic
+
+In this example we show the use of a custom `rtic::Monotonic` implementation
+which uses a 16 bit timer of the `STM32L0` MCU.
+
+## Flashing and running
+
+Flashing with a standard STLink v2 is easy with `cargo-embed`:
+
+```shell
+$ cargo install cargo-embed
+$ cargo embed --release
+```
+
+Please review the `.embed.toml` file to change your target IC among other options.

rtic_v1/stm32l0_monotonic/src/main.rs

@@ -0,0 +1,116 @@
+#![no_main]
+#![no_std]
+
+use panic_rtt_target as _;
+
+mod monotonic_stm32l0;
+use core::fmt::Write;
+use embedded_time::rate::Baud;
+use monotonic_stm32l0::{Duration, Instant, Tim6Monotonic, U16Ext};
+use rtic::app;
+use rtt_target::{rprintln, rtt_init_print};
+use stm32l0xx_hal::{pac, prelude::*, rcc::Config, serial};
+
+const INTERVAL_MS: u16 = 500;
+
+#[app(
+    device = stm32l0xx_hal::pac,
+    peripherals = true,
+    dispatchers = [SPI1],
+)]
+mod app {
+    use super::*;
+
+    // Setting this monotonic as the default
+    // enables the shorthand fizzbuzz::spawn_after
+    // without having to specify `Mono` as fizzbuzz::Mono::spawn_after(
+    #[monotonic(binds = TIM6, default = true)]
+    type Mono = Tim6Monotonic;
+
+    #[local]
+    struct Local {
+        /// Serial debug output
+        // serial: serial::Serial<pac::USART1>,
+
+        /// Timer interval
+        interval: Duration,
+
+        /// Counter
+        counter: usize,
+    }
+
+    #[shared]
+    struct Shared {}
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
+        // Get peripherals
+        let dp: pac::Peripherals = cx.device;
+
+        // Clock configuration. Use HSI at 16 MHz.
+        let mut rcc = dp.RCC.freeze(Config::hsi16());
+
+        rtt_init_print!();
+        rprintln!("RTT init");
+
+        // GPIO
+        let gpiob = dp.GPIOB.split(&mut rcc);
+
+        // Initialize the timer TIM6.
+        //writeln!(
+        //serial,
+        //"Initialize monotonic timer (TIM6) at 7.8125 kHz (128 μs)"
+        //)
+        //.unwrap();
+        let mono = Tim6Monotonic::initialize(dp.TIM6);
+
+        let interval = INTERVAL_MS.millis();
+        //writeln!(
+        //serial,
+        //"Schedule task every {} ms / {} ticks",
+        //INTERVAL_MS,
+        //interval.as_ticks()
+        //)
+        //.unwrap();
+
+        // Spawn task "fizzbuzz"
+        let _ = fizzbuzz::spawn();
+
+        //writeln!(serial, "== Init done ==").unwrap();
+
+        let local = Local {
+            //serial,
+            interval,
+            counter: 1,
+        };
+
+        (Shared {}, local, init::Monotonics(mono))
+    }
+
+    #[task(local = [/*serial,*/ interval, counter])]
+    fn fizzbuzz(cx: fizzbuzz::Context) {
+        rprintln!("fizzbuzz!");
+        // Access resources
+        //let serial = cx.local.serial;
+        let now = Instant::now().counts();
+        let counter = cx.local.counter;
+
+        // Fancy fizzbuzz implementation
+        match (*counter % 3 == 0, *counter % 5 == 0) {
+            (true, true) => rprintln!("fizzbuzz (now={:05})", now),
+            (true, false) => rprintln!("    fizz (now={:05})", now),
+            (false, true) => rprintln!("    buzz (now={:05})", now),
+            _ => rprintln!("{:08} (now={:05})", *counter, now),
+            //(true, true) => writeln!(serial, "fizzbuzz (now={:05})", now).unwrap(),
+            //(true, false) => writeln!(serial, "    fizz (now={:05})", now).unwrap(),
+            //(false, true) => writeln!(serial, "    buzz (now={:05})", now).unwrap(),
+            //_ => writeln!(serial, "{:08} (now={:05})", *counter, now).unwrap(),
+        }
+
+        // Increment counter
+        *counter += 1;
+
+        // Re-schedule
+        let _ = fizzbuzz::spawn_after(*cx.local.interval);
+    }
+}