Switch to systick-monotonic and reenable serial

Completely untested, if somebody has hardware handy please test

Author: AfoHT

rtic_v1/stm32l0_monotonic/Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 
 [dependencies]
 cortex-m-rtic = "1.0.0"
-embedded-time = "0.12.1"
+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"] }

rtic_v1/stm32l0_monotonic/src/main.rs

@@ -1,20 +1,19 @@
 #![no_main]
 #![no_std]
 
-mod monotonic_stm32l0;
-
 use core::fmt::Write;
 
 use panic_rtt_target as _;
 use rtt_target::{rprintln, rtt_init_print};
 
-use embedded_time::rate::Baud;
 use rtic::app;
 use stm32l0xx_hal::{pac, prelude::*, rcc::Config, serial};
+use systick_monotonic::{
+    fugit::{ExtU32, MillisDurationU64},
+    Systick,
+};
 
-use monotonic_stm32l0::{Duration, Instant, Tim6Monotonic, U16Ext};
-
-const INTERVAL_MS: u16 = 500;
+const INTERVAL_MS: u32 = 500;
 
 #[app(
     device = stm32l0xx_hal::pac,
@@ -27,16 +26,16 @@ mod app {
     // 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;
+    #[monotonic(binds = SysTick, default = true)]
+    type Tonic = Systick<1000>;
 
     #[local]
     struct Local {
         /// Serial debug output
-        // serial: serial::Serial<pac::USART1>,
+        serial: serial::Serial<pac::USART2>,
 
         /// Timer interval
-        interval: Duration,
+        interval: MillisDurationU64,
 
         /// Counter
         counter: usize,
@@ -59,61 +58,83 @@ mod app {
         // 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();
+        // 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();
+        writeln!(serial, "== Init done ==").unwrap();
 
         let local = Local {
-            //serial,
+            serial,
             interval,
             counter: 1,
         };
 
         (Shared {}, local, init::Monotonics(mono))
     }
 
-    #[task(local = [/*serial,*/ interval, counter])]
+    #[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 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),
-            (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(),
+            (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(*cx.local.interval);
+        let _ = fizzbuzz::spawn_after(*interval);
     }
 }