New monotonic trait working

5 files changed, 40 insertions, 51 deletions

diff --git a/examples/cancel-reschedule.rs b/examples/cancel-reschedule.rs
index c5ef2e73..e0bdaae8 100644
--- a/examples/cancel-reschedule.rs
+++ b/examples/cancel-reschedule.rs
@@ -10,8 +10,7 @@ use panic_semihosting as _;
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
 mod app {
     use cortex_m_semihosting::{debug, hprintln};
-    use rtic::time::duration::*;
-    use systick_monotonic::Systick;
+    use systick_monotonic::*;
 
     #[monotonic(binds = SysTick, default = true)]
     type MyMono = Systick<100>; // 100 Hz / 10 ms granularity
@@ -32,7 +31,7 @@ mod app {
         hprintln!("init").ok();
 
         // Schedule `foo` to run 1 second in the future
-        foo::spawn_after(1.seconds()).unwrap();
+        foo::spawn_after(1.secs()).unwrap();
 
         (
             Shared {},
@@ -46,8 +45,8 @@ mod app {
         hprintln!("foo").ok();
 
         // Schedule `bar` to run 2 seconds in the future (1 second after foo runs)
-        let spawn_handle = baz::spawn_after(2.seconds()).unwrap();
-        bar::spawn_after(1.seconds(), spawn_handle, false).unwrap(); // Change to true
+        let spawn_handle = baz::spawn_after(2.secs()).unwrap();
+        bar::spawn_after(1.secs(), spawn_handle, false).unwrap(); // Change to true
     }
 
     #[task]
@@ -57,7 +56,7 @@ mod app {
         if do_reschedule {
             // Reschedule baz 2 seconds from now, instead of the original 1 second
             // from now.
-            baz_handle.reschedule_after(2.seconds()).unwrap();
+            baz_handle.reschedule_after(2.secs()).unwrap();
             // Or baz_handle.reschedule_at(/* time */)
         } else {
             // Or cancel it
diff --git a/examples/common.rs b/examples/common.rs
index 770a0ae5..26a5c8fb 100644
--- a/examples/common.rs
+++ b/examples/common.rs
@@ -10,8 +10,7 @@ use panic_semihosting as _;
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0, QEI0])]
 mod app {
     use cortex_m_semihosting::{debug, hprintln};
-    use rtic::time::duration::*;
-    use systick_monotonic::Systick; // Implements the `Monotonic` trait // Time helpers, such as `N.seconds()`
+    use systick_monotonic::*; // Implements the `Monotonic` trait
 
     // A monotonic timer to enable scheduling in RTIC
     #[monotonic(binds = SysTick, default = true)]
@@ -41,7 +40,7 @@ mod app {
 
         // Spawn the task `bar` 1 second after `init` finishes, this is enabled
         // by the `#[monotonic(..)]` above
-        bar::spawn_after(1.seconds()).unwrap();
+        bar::spawn_after(1.secs()).unwrap();
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
 
@@ -83,7 +82,7 @@ mod app {
         hprintln!("bar").ok();
 
         // Run `bar` once per second
-        bar::spawn_after(1.seconds()).unwrap();
+        bar::spawn_after(1.secs()).unwrap();
     }
 
     // Hardware task, bound to a hardware interrupt
diff --git a/examples/periodic.rs b/examples/periodic.rs
index 3066def7..495054ea 100644
--- a/examples/periodic.rs
+++ b/examples/periodic.rs
@@ -10,8 +10,7 @@ use panic_semihosting as _;
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
 mod app {
     use cortex_m_semihosting::{debug, hprintln};
-    use rtic::time::duration::*;
-    use systick_monotonic::Systick;
+    use systick_monotonic::*;
 
     #[monotonic(binds = SysTick, default = true)]
     type MyMono = Systick<100>; // 100 Hz / 10 ms granularity
@@ -28,7 +27,7 @@ mod app {
 
         let mono = Systick::new(systick, 12_000_000);
 
-        foo::spawn_after(1.seconds()).unwrap();
+        foo::spawn_after(1.secs()).unwrap();
 
         (Shared {}, Local {}, init::Monotonics(mono))
     }
@@ -43,6 +42,6 @@ mod app {
         }
 
         // Periodic ever 1 seconds
-        foo::spawn_after(1.seconds()).unwrap();
+        foo::spawn_after(1.secs()).unwrap();
     }
 }
diff --git a/examples/schedule.rs b/examples/schedule.rs
index 669c67c9..446a3828 100644
--- a/examples/schedule.rs
+++ b/examples/schedule.rs
@@ -10,8 +10,7 @@ use panic_semihosting as _;
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
 mod app {
     use cortex_m_semihosting::{debug, hprintln};
-    use rtic::time::duration::*;
-    use systick_monotonic::Systick;
+    use systick_monotonic::*;
 
     #[monotonic(binds = SysTick, default = true)]
     type MyMono = Systick<100>; // 100 Hz / 10 ms granularity
@@ -32,7 +31,7 @@ mod app {
         hprintln!("init").ok();
 
         // Schedule `foo` to run 1 second in the future
-        foo::spawn_after(1.seconds()).unwrap();
+        foo::spawn_after(1.secs()).unwrap();
 
         (
             Shared {},
@@ -46,7 +45,7 @@ mod app {
         hprintln!("foo").ok();
 
         // Schedule `bar` to run 2 seconds in the future (1 second after foo runs)
-        bar::spawn_after(1.seconds()).unwrap();
+        bar::spawn_after(1.secs()).unwrap();
     }
 
     #[task]
@@ -54,7 +53,7 @@ mod app {
         hprintln!("bar").ok();
 
         // Schedule `baz` to run 1 seconds from now, but with a specific time instant.
-        baz::spawn_at(monotonics::now() + 1.seconds()).unwrap();
+        baz::spawn_at(monotonics::now() + 1.secs()).unwrap();
     }
 
     #[task]
diff --git a/examples/t-schedule.rs b/examples/t-schedule.rs
index 5530ec6a..6ee08afb 100644
--- a/examples/t-schedule.rs
+++ b/examples/t-schedule.rs
@@ -10,8 +10,7 @@ use panic_semihosting as _;
 #[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
 mod app {
     use cortex_m_semihosting::debug;
-    use rtic::time::duration::Seconds;
-    use systick_monotonic::Systick;
+    use systick_monotonic::*;
 
     #[monotonic(binds = SysTick, default = true)]
     type MyMono = Systick<100>; // 100 Hz / 10 ms granularity
@@ -40,27 +39,26 @@ mod app {
         // Not default
         let _: Result<foo::MyMono::SpawnHandle, ()> =
             foo::MyMono::spawn_at(monotonics::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(1.secs());
+        let _: Result<foo::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_after(1.secs());
 
-        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
+        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(1.secs());
         let _: Result<foo::MyMono::SpawnHandle, ()> =
             handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
-        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(Seconds(1_u32));
+        let handle: Result<foo::MyMono::SpawnHandle, ()> = foo::MyMono::spawn_after(1.secs());
         let _: Result<(), ()> = handle.unwrap().cancel();
 
         // Using default
         let _: Result<foo::SpawnHandle, ()> = foo::spawn_at(monotonics::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(1.secs());
+        let _: Result<foo::SpawnHandle, ()> = handle.unwrap().reschedule_after(1.secs());
 
-        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
+        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(1.secs());
         let _: Result<foo::SpawnHandle, ()> =
             handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
-        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(Seconds(1_u32));
+        let handle: Result<foo::SpawnHandle, ()> = foo::spawn_after(1.secs());
         let _: Result<(), ()> = handle.unwrap().cancel();
 
         // Task with single message passing
@@ -68,30 +66,26 @@ mod app {
         // Not default
         let _: Result<bar::MyMono::SpawnHandle, u32> =
             bar::MyMono::spawn_at(monotonics::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(1.secs(), 1);
+        let _: Result<bar::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_after(1.secs());
 
-        let handle: Result<bar::MyMono::SpawnHandle, u32> =
-            bar::MyMono::spawn_after(Seconds(1_u32), 0);
+        let handle: Result<bar::MyMono::SpawnHandle, u32> = bar::MyMono::spawn_after(1.secs(), 1);
         let _: Result<bar::MyMono::SpawnHandle, ()> =
             handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
-        let handle: Result<bar::MyMono::SpawnHandle, u32> =
-            bar::MyMono::spawn_after(Seconds(1_u32), 0);
+        let handle: Result<bar::MyMono::SpawnHandle, u32> = bar::MyMono::spawn_after(1.secs(), 1);
         let _: Result<u32, ()> = handle.unwrap().cancel();
 
         // Using default
         let _: Result<bar::SpawnHandle, u32> = bar::spawn_at(monotonics::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(1.secs(), 1);
+        let _: Result<bar::SpawnHandle, ()> = handle.unwrap().reschedule_after(1.secs());
 
-        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
+        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(1.secs(), 1);
         let _: Result<bar::SpawnHandle, ()> =
             handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
-        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(Seconds(1_u32), 0);
+        let handle: Result<bar::SpawnHandle, u32> = bar::spawn_after(1.secs(), 1);
         let _: Result<u32, ()> = handle.unwrap().cancel();
 
         // Task with multiple message passing
@@ -100,30 +94,29 @@ mod app {
         let _: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
             baz::MyMono::spawn_at(monotonics::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));
+            baz::MyMono::spawn_after(1.secs(), 1, 2);
+        let _: Result<baz::MyMono::SpawnHandle, ()> = handle.unwrap().reschedule_after(1.secs());
 
         let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
-            baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
+            baz::MyMono::spawn_after(1.secs(), 1, 2);
         let _: Result<baz::MyMono::SpawnHandle, ()> =
             handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
         let handle: Result<baz::MyMono::SpawnHandle, (u32, u32)> =
-            baz::MyMono::spawn_after(Seconds(1_u32), 0, 1);
+            baz::MyMono::spawn_after(1.secs(), 1, 2);
         let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
 
         // Using default
         let _: Result<baz::SpawnHandle, (u32, u32)> =
             baz::spawn_at(monotonics::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(1.secs(), 1, 2);
+        let _: Result<baz::SpawnHandle, ()> = handle.unwrap().reschedule_after(1.secs());
 
-        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
+        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(1.secs(), 1, 2);
         let _: Result<baz::SpawnHandle, ()> =
             handle.unwrap().reschedule_at(monotonics::MyMono::now());
 
-        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
+        let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(1.secs(), 1, 2);
         let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
 
         loop {