Merge #37

37: Add stm32l0-monotonic example for RTIC v1.0 r=AfoHT a=barafael

This example was ported from rtic_v0.5/stm32l0_monotonic. I cannot test as the only L0 chip I have is one without TIM6 which is needed. I have one coming in the mail though :)

Co-authored-by: Rafael Bachmann <[email protected]>
Co-authored-by: Henrik Tjäder <[email protected]>

Author: 3 people

.github/dependabot.yml

@@ -75,6 +75,11 @@ updates:
     schedule:
       interval: "weekly"
     rebase-strategy: "disabled"
+  - package-ecosystem: "cargo"
+    directory: "/rtic_v1/stm32l0_monotonic"
+    schedule:
+      interval: "weekly"
+    rebase-strategy: "disabled"
   - package-ecosystem: "cargo"
     directory: "/rtic_v1/stm32l4_heartbeat"
     schedule:

rtic_v0.5/stm32l0_monotonic/src/main.rs

@@ -7,8 +7,7 @@ use core::fmt::Write;
 
 use panic_halt as _;
 use rtic::app;
-use stm32l0xx_hal::prelude::*;
-use stm32l0xx_hal::{pac, rcc::Config, serial};
+use stm32l0xx_hal::{pac, prelude::*, rcc::Config, serial};
 
 use crate::monotonic_stm32l0::{Duration, Instant, Tim6Monotonic, U16Ext};
 

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 <[email protected]>"]
+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"
+systick-monotonic = "1.0.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,140 @@
+#![no_main]
+#![no_std]
+
+use core::fmt::Write;
+
+use panic_rtt_target as _;
+use rtt_target::{rprintln, rtt_init_print};
+
+use rtic::app;
+use stm32l0xx_hal::{pac, prelude::*, rcc::Config, serial};
+use systick_monotonic::{
+    fugit::{ExtU32, MillisDurationU64},
+    Systick,
+};
+
+const INTERVAL_MS: u32 = 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 = SysTick, default = true)]
+    type Tonic = Systick<1000>;
+
+    #[local]
+    struct Local {
+        /// Serial debug output
+        serial: serial::Serial<pac::USART2>,
+
+        /// Timer interval
+        interval: MillisDurationU64,
+
+        /// 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 serial port(s)
+        let mut serial = serial::Serial::usart2(
+            dp.USART2,
+            gpiob.pb6.into_floating_input(),
+            gpiob.pb7.into_floating_input(),
+            serial::Config {
+                baudrate: 57_600.Bd(),
+                wordlength: serial::WordLength::DataBits8,
+                parity: serial::Parity::ParityNone,
+                stopbits: serial::StopBits::STOP1,
+            },
+            &mut rcc,
+        )
+        .unwrap();
+
+        // Initialize the timer
+        writeln!(serial, "Initialize monotonic timer using SysTick at 1kHz").unwrap();
+
+        let mono = Systick::new(cx.core.SYST, 16_000_000);
+
+        let interval: MillisDurationU64 = INTERVAL_MS.millis().into();
+
+        writeln!(
+            serial,
+            "Schedule task every {} ms / {} ticks",
+            interval,
+            interval.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 = monotonics::now();
+        let counter = cx.local.counter;
+        let interval = cx.local.interval;
+
+        // Fancy fizzbuzz implementation
+        match (*counter % 3 == 0, *counter % 5 == 0) {
+            (true, true) => {
+                rprintln!("fizzbuzz (now={:05})", now);
+                writeln!(serial, "fizzbuzz (now={:05})", now).unwrap();
+            }
+            (true, false) => {
+                rprintln!("    fizz (now={:05})", now);
+                writeln!(serial, "    fizz (now={:05})", now).unwrap();
+            }
+            (false, true) => {
+                rprintln!("    buzz (now={:05})", now);
+                writeln!(serial, "    buzz (now={:05})", now).unwrap();
+            }
+            _ => {
+                rprintln!("{:08} (now={:05})", *counter, now);
+                writeln!(serial, "{:08} (now={:05})", *counter, now).unwrap();
+            }
+        }
+
+        // Increment counter
+        *counter += 1;
+
+        // Re-schedule
+        let _ = fizzbuzz::spawn_after(*interval);
+    }
+}