rtfm_schedule.rs

examples/rtfm_schedule.rs

+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![no_main]
+#![no_std]
+
+use cortex_m::peripheral::DWT;
+use cortex_m_semihosting::hprintln;
+use panic_halt as _;
+use rtfm::cyccnt::{Instant, U32Ext as _};
+
+#[rtfm::app(device = stm32f4xx_hal::stm32, monotonic = rtfm::cyccnt::CYCCNT)]
+const APP: () = {
+    #[init(schedule = [foo, bar])]
+    fn init(cx: init::Context) {
+        let mut core = cx.core;
+
+        // Initialize (enable) the monotonic timer (CYCCNT)
+        core.DCB.enable_trace();
+        // required on Cortex-M7 devices that software lock the DWT (e.g. STM32F7)
+        DWT::unlock();
+        core.DWT.enable_cycle_counter();
+
+        // semantically, the monotonic timer is frozen at time "zero" during `init`
+        // NOTE do *not* call `Instant::now` in this context; it will return a nonsense value
+        let now = cx.start; // the start time of the system
+
+        hprintln!("init @ {:?}", now).unwrap();
+
+        // Schedule `foo` to run 8e6 cycles (clock cycles) in the future
+        cx.schedule.foo(now + 8_000_000.cycles()).unwrap();
+
+        // Schedule `bar` to run 4e6 cycles in the future
+        cx.schedule.bar(now + 4_000_000.cycles()).unwrap();
+    }
+
+    #[task]
+    fn foo(_: foo::Context) {
+        hprintln!("foo  @ {:?}", Instant::now()).unwrap();
+    }
+
+    #[task]
+    fn bar(_: bar::Context) {
+        hprintln!("bar  @ {:?}", Instant::now()).unwrap();
+    }
+
+    extern "C" {
+        fn EXTI0();
+    }
+};