Merge #456

456: Cancel/reschedule support for monotonics r=AfoHT a=korken89

Design document: https://hackmd.io/lhUCzrKBS-66aadO4KsSzw?view

Co-authored-by: Emil Fresk <emil.fresk@gmail.com>

1 files changed, 83 insertions, 12 deletions

diff --git a/examples/t-schedule.rs b/examples/t-schedule.rs
index bd0ab66..ef04c45 100644
--- a/examples/t-schedule.rs
+++ b/examples/t-schedule.rs
@@ -9,14 +9,11 @@ use panic_semihosting as _;
 
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
 mod app {
-    use dwt_systick_monotonic::{
-        consts::{U0, U8},
-        DwtSystick,
-    };
+    use dwt_systick_monotonic::DwtSystick;
     use rtic::time::duration::Seconds;
 
     #[monotonic(binds = SysTick, default = true)]
-    type MyMono = DwtSystick<U8, U0, U0>; // 8 MHz
+    type MyMono = DwtSystick<8_000_000>; // 8 MHz
 
     #[init]
     fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
@@ -26,19 +23,93 @@ mod app {
 
         let mono = DwtSystick::new(&mut dcb, dwt, systick, 8_000_000);
 
-        let _: Result<(), ()> = foo::spawn_after(Seconds(1_u32));
-        let _: Result<(), u32> = bar::spawn_after(Seconds(2_u32), 0);
-        let _: Result<(), (u32, u32)> = baz::spawn_after(Seconds(3_u32), 0, 1);
+        // Task without message passing
+
+        // Not default
+        let _: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_at(MyMono::now());
+        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
+        let _: Result<foo::MyMono::SpawnHandle, ()> =
+            handle.unwrap().reschedule_after(Seconds(1_u32));
+
+        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
+        let _: Result<foo::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+
+        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
+        let _: Result<(), ()> = handle.unwrap().cancel();
+
+        // Using default
+        let _: Result<foo::SpawnHandle, ()> = foo::spawn_at(MyMono::now());
+        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
+        let _: Result<foo::SpawnHandle, ()> = handle.unwrap().reschedule_after(Seconds(1_u32));
+
+        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
+        let _: Result<foo::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+
+        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
+        let _: Result<(), ()> = handle.unwrap().cancel();
+
+        // Task with single message passing
+
+        // Not default
+        let _: Result<bar::MyMono::SpawnHandle, u32> = bar::MyMono::spawn_at(MyMono::now(), 0);
+        let handle: Result<bar::MyMono::SpawnHandle, u32> =
+            bar::MyMono::spawn_after(Seconds(1_u32), 0);
+        let _: Result<bar::MyMono::SpawnHandle, ()> =
+            handle.unwrap().reschedule_after(Seconds(1_u32));
+
+        let handle: Result<bar::MyMono::SpawnHandle, u32> =
+            bar::MyMono::spawn_after(Seconds(1_u32), 0);
+        let _: Result<bar::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+
+        let handle: Result<bar::MyMono::SpawnHandle, u32> =
+            bar::MyMono::spawn_after(Seconds(1_u32), 0);
+        let _: Result<u32, ()> = handle.unwrap().cancel();
+
+        // Using default
+        let _: Result<bar::SpawnHandle, u32> = bar::spawn_at(MyMono::now(), 0);
+        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
+        let _: Result<bar::SpawnHandle, ()> = handle.unwrap().reschedule_after(Seconds(1_u32));
+
+        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
+        let _: Result<bar::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+
+        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
+        let _: Result<u32, ()> = handle.unwrap().cancel();
+
+        // Task with multiple message passing
+
+        // Not default
+        let _: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
+            baz::MyMono::spawn_at(MyMono::now(), 0, 1);
+        let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
+            baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
+        let _: Result<baz::MyMono::SpawnHandle, ()> =
+            handle.unwrap().reschedule_after(Seconds(1_u32));
+
+        let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
+            baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
+        let _: Result<baz::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+
+        let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
+            baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
+        let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
+
+        // Using default
+        let _: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_at(MyMono::now(), 0, 1);
+        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
+        let _: Result<baz::SpawnHandle, ()> = handle.unwrap().reschedule_after(Seconds(1_u32));
+
+        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
+        let _: Result<baz::SpawnHandle, ()> = handle.unwrap().reschedule_at(MyMono::now());
+
+        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
+        let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
 
         (init::LateResources {}, init::Monotonics(mono))
     }
 
     #[idle]
     fn idle(_: idle::Context) -> ! {
-        let _: Result<(), ()> = foo::spawn_at(MyMono::now() + Seconds(3_u32));
-        let _: Result<(), u32> = bar::spawn_at(MyMono::now() + Seconds(4_u32), 0);
-        let _: Result<(), (u32, u32)> = baz::spawn_at(MyMono::now() + Seconds(5_u32), 0, 1);
-
         loop {
             cortex_m::asm::nop();
         }