rtic-rs
diff --git a/‎CHANGELOG.md‎
Lines changed: 1 addition & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎Cargo.toml‎
Lines changed: 1 addition & 1 deletion b/‎Cargo.toml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎examples/binds.rs‎
Lines changed: 6 additions & 6 deletions b/‎examples/binds.rs‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎examples/cancel-reschedule.rs‎
Lines changed: 4 additions & 4 deletions b/‎examples/cancel-reschedule.rs‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎examples/capacity.rs‎
Lines changed: 2 additions & 2 deletions b/‎examples/capacity.rs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎examples/cfg-whole-task.rs‎
Lines changed: 1 addition & 2 deletions b/‎examples/cfg-whole-task.rs‎
Lines changed: 1 addition & 2 deletions
diff --git a/‎examples/common.rs‎
Lines changed: 3 additions & 3 deletions b/‎examples/common.rs‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎examples/complex.rs‎
Lines changed: 25 additions & 28 deletions b/‎examples/complex.rs‎
Lines changed: 25 additions & 28 deletions
diff --git a/‎examples/destructure.rs‎
Lines changed: 2 additions & 2 deletions b/‎examples/destructure.rs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎examples/extern_binds.rs‎
Lines changed: 6 additions & 5 deletions b/‎examples/extern_binds.rs‎
Lines changed: 6 additions & 5 deletions
@@ -19,6 +19,7 @@ For each category, *Added*, *Changed*, *Fixed* add new entries at the top!
 
 ### Changed
 
+- Updated dev-dependency cortex-m-semihosting to v0.5
 - CI: Updated to setup-python@v4
 - CI: Updated to checkout@v3
 - Tuned redirect message for rtic.rs/meeting
 
@@ -32,7 +32,7 @@ version_check = "0.9"
 
 [dev-dependencies]
 lm3s6965 = "0.1.3"
-cortex-m-semihosting = "0.3.3"
+cortex-m-semihosting = "0.5.0"
 systick-monotonic = "1.0.0"
 
 [dev-dependencies.panic-semihosting]
 
@@ -23,21 +23,22 @@ mod app {
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtic::pend(Interrupt::UART0);
 
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (Shared {}, Local {}, init::Monotonics())
     }
 
     #[idle]
     fn idle(_: idle::Context) -> ! {
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         rtic::pend(Interrupt::UART0);
 
-        debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
-
         loop {
+            // Exit moved after nop to ensure that rtic::pend gets
+            // to run before exiting
             cortex_m::asm::nop();
+            debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
         }
     }
 
@@ -49,7 +50,6 @@ mod app {
             "foo called {} time{}",
             *cx.local.times,
             if *cx.local.times > 1 { "s" } else { "" }
-        )
-        .unwrap();
+        );
     }
 }
@@ -28,7 +28,7 @@ mod app {
         // Initialize the monotonic (SysTick rate in QEMU is 12 MHz)
         let mono = Systick::new(systick, 12_000_000);
 
-        hprintln!("init").ok();
+        hprintln!("init");
 
         // Schedule `foo` to run 1 second in the future
         foo::spawn_after(1.secs()).unwrap();
@@ -42,7 +42,7 @@ mod app {
 
     #[task]
     fn foo(_: foo::Context) {
-        hprintln!("foo").ok();
+        hprintln!("foo");
 
         // Schedule `bar` to run 2 seconds in the future (1 second after foo runs)
         let spawn_handle = baz::spawn_after(2.secs()).unwrap();
@@ -51,7 +51,7 @@ mod app {
 
     #[task]
     fn bar(_: bar::Context, baz_handle: baz::SpawnHandle, do_reschedule: bool) {
-        hprintln!("bar").ok();
+        hprintln!("bar");
 
         if do_reschedule {
             // Reschedule baz 2 seconds from now, instead of the original 1 second
@@ -67,7 +67,7 @@ mod app {
 
     #[task]
     fn baz(_: baz::Context) {
-        hprintln!("baz").ok();
+        hprintln!("baz");
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
 }
@@ -37,12 +37,12 @@ mod app {
 
     #[task(capacity = 4)]
     fn foo(_: foo::Context, x: u32) {
-        hprintln!("foo({})", x).unwrap();
+        hprintln!("foo({})", x);
     }
 
     #[task]
     fn bar(_: bar::Context) {
-        hprintln!("bar").unwrap();
+        hprintln!("bar");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
 
@@ -88,7 +88,6 @@ mod app {
             "foo has been called {} time{}",
             n,
             if n == 1 { "" } else { "s" }
-        )
-        .ok();
+        );
     }
 }
@@ -73,15 +73,15 @@ mod app {
         // This task is only spawned once in `init`, hence this task will run
         // only once
 
-        hprintln!("foo").ok();
+        hprintln!("foo");
     }
 
     // Software task, also not bound to a hardware interrupt
     // This task takes the task local resource `l2`
     // The resources `s1` and `s2` are shared between all other tasks.
     #[task(shared = [s1, s2], local = [l2])]
     fn bar(_: bar::Context) {
-        hprintln!("bar").ok();
+        hprintln!("bar");
 
         // Run `bar` once per second
         bar::spawn_after(1.secs()).unwrap();
@@ -97,6 +97,6 @@ mod app {
         // Note that RTIC does NOT clear the interrupt flag, this is up to the
         // user
 
-        hprintln!("UART0 interrupt!").ok();
+        hprintln!("UART0 interrupt!");
     }
 }
@@ -25,7 +25,7 @@ mod app {
 
     #[init]
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (
             Shared {
@@ -40,31 +40,31 @@ mod app {
 
     #[idle(shared = [s2, s3])]
     fn idle(mut cx: idle::Context) -> ! {
-        hprintln!("idle p0 started").ok();
+        hprintln!("idle p0 started");
         rtic::pend(Interrupt::GPIOC);
         cx.shared.s3.lock(|s| {
-            hprintln!("idle enter lock s3 {}", s).ok();
-            hprintln!("idle pend t0").ok();
+            hprintln!("idle enter lock s3 {}", s);
+            hprintln!("idle pend t0");
             rtic::pend(Interrupt::GPIOA); // t0 p2, with shared ceiling 3
-            hprintln!("idle pend t1").ok();
+            hprintln!("idle pend t1");
             rtic::pend(Interrupt::GPIOB); // t1 p3, with shared ceiling 3
-            hprintln!("idle pend t2").ok();
+            hprintln!("idle pend t2");
             rtic::pend(Interrupt::GPIOC); // t2 p4, no sharing
-            hprintln!("idle still in lock s3 {}", s).ok();
+            hprintln!("idle still in lock s3 {}", s);
         });
-        hprintln!("\nback in idle").ok();
+        hprintln!("\nback in idle");
 
         cx.shared.s2.lock(|s| {
-            hprintln!("enter lock s2 {}", s).ok();
-            hprintln!("idle pend t0").ok();
+            hprintln!("enter lock s2 {}", s);
+            hprintln!("idle pend t0");
             rtic::pend(Interrupt::GPIOA); // t0 p2, with shared ceiling 2
-            hprintln!("idle pend t1").ok();
+            hprintln!("idle pend t1");
             rtic::pend(Interrupt::GPIOB); // t1 p3, no sharing
-            hprintln!("idle pend t2").ok();
+            hprintln!("idle pend t2");
             rtic::pend(Interrupt::GPIOC); // t2 p4, no sharing
-            hprintln!("idle still in lock s2 {}", s).ok();
+            hprintln!("idle still in lock s2 {}", s);
         });
-        hprintln!("\nidle exit").ok();
+        hprintln!("\nidle exit");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
 
@@ -82,9 +82,8 @@ mod app {
             "t0 p2 called {} time{}",
             *cx.local.times,
             if *cx.local.times > 1 { "s" } else { "" }
-        )
-        .ok();
-        hprintln!("t0 p2 exit").ok();
+        );
+        hprintln!("t0 p2 exit");
     }
 
     #[task(binds = GPIOB, priority = 3, local = [times: u32 = 0], shared = [s3, s4])]
@@ -96,19 +95,18 @@ mod app {
             "t1 p3 called {} time{}",
             *cx.local.times,
             if *cx.local.times > 1 { "s" } else { "" }
-        )
-        .ok();
+        );
 
         cx.shared.s4.lock(|s| {
-            hprintln!("t1 enter lock s4 {}", s).ok();
-            hprintln!("t1 pend t0").ok();
+            hprintln!("t1 enter lock s4 {}", s);
+            hprintln!("t1 pend t0");
             rtic::pend(Interrupt::GPIOA); // t0 p2, with shared ceiling 2
-            hprintln!("t1 pend t2").ok();
+            hprintln!("t1 pend t2");
             rtic::pend(Interrupt::GPIOC); // t2 p4, no sharing
-            hprintln!("t1 still in lock s4 {}", s).ok();
+            hprintln!("t1 still in lock s4 {}", s);
         });
 
-        hprintln!("t1 p3 exit").ok();
+        hprintln!("t1 p3 exit");
     }
 
     #[task(binds = GPIOC, priority = 4, local = [times: u32 = 0], shared = [s4])]
@@ -120,13 +118,12 @@ mod app {
             "t2 p4 called {} time{}",
             *cx.local.times,
             if *cx.local.times > 1 { "s" } else { "" }
-        )
-        .unwrap();
+        );
 
         cx.shared.s4.lock(|s| {
-            hprintln!("enter lock s4 {}", s).ok();
+            hprintln!("enter lock s4 {}", s);
             *s += 1;
         });
-        hprintln!("t3 p4 exit").ok();
+        hprintln!("t3 p4 exit");
     }
 }
@@ -42,14 +42,14 @@ mod app {
         let b = cx.shared.b;
         let c = cx.shared.c;
 
-        hprintln!("foo: a = {}, b = {}, c = {}", a, b, c).unwrap();
+        hprintln!("foo: a = {}, b = {}, c = {}", a, b, c);
     }
 
     // De-structure-ing syntax
     #[task(shared = [&a, &b, &c])]
     fn bar(cx: bar::Context) {
         let bar::SharedResources { a, b, c } = cx.shared;
 
-        hprintln!("bar: a = {}, b = {}, c = {}", a, b, c).unwrap();
+        hprintln!("bar: a = {}, b = {}, c = {}", a, b, c);
     }
 }
@@ -10,7 +10,7 @@ use panic_semihosting as _;
 
 // Free function implementing the interrupt bound task `foo`.
 fn foo(_: app::foo::Context) {
-    hprintln!("foo called").ok();
+    hprintln!("foo called");
 }
 
 #[rtic::app(device = lm3s6965)]
@@ -29,21 +29,22 @@ mod app {
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtic::pend(Interrupt::UART0);
 
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (Shared {}, Local {}, init::Monotonics())
     }
 
     #[idle]
     fn idle(_: idle::Context) -> ! {
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         rtic::pend(Interrupt::UART0);
 
-        debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
-
         loop {
             cortex_m::asm::nop();
+            // Exit moved after nop to ensure that rtic::pend gets
+            // to run before exiting
+            debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
         }
     }
Original file line number	Diff line number	Diff line change
`@@ -23,21 +23,22 @@ mod app {`
`23`	`23`	`fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {`
`24`	`24`	`rtic::pend(Interrupt::UART0);`
`25`	`25`
`26`		`- hprintln!("init").unwrap();`
	`26`	`+ hprintln!("init");`
`27`	`27`
`28`	`28`	`(Shared {}, Local {}, init::Monotonics())`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`#[idle]`
`32`	`32`	`fn idle(_: idle::Context) -> ! {`
`33`		`- hprintln!("idle").unwrap();`
	`33`	`+ hprintln!("idle");`
`34`	`34`
`35`	`35`	`rtic::pend(Interrupt::UART0);`
`36`	`36`
`37`		`- debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator`
`38`		`-`
`39`	`37`	`loop {`
	`38`	`+ // Exit moved after nop to ensure that rtic::pend gets`
	`39`	`+ // to run before exiting`
`40`	`40`	`cortex_m::asm::nop();`
	`41`	`+ debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`
`@@ -49,7 +50,6 @@ mod app {`
`49`	`50`	`"foo called {} time{}",`
`50`	`51`	`*cx.local.times,`
`51`	`52`	`if *cx.local.times > 1 { "s" } else { "" }`
`52`		`- )`
`53`		`- .unwrap();`
	`53`	`+ );`
`54`	`54`	`}`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,12 +37,12 @@ mod app {`
`37`	`37`
`38`	`38`	`#[task(capacity = 4)]`
`39`	`39`	`fn foo(_: foo::Context, x: u32) {`
`40`		`- hprintln!("foo({})", x).unwrap();`
	`40`	`+ hprintln!("foo({})", x);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`#[task]`
`44`	`44`	`fn bar(_: bar::Context) {`
`45`		`- hprintln!("bar").unwrap();`
	`45`	`+ hprintln!("bar");`
`46`	`46`
`47`	`47`	`debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,6 @@ mod app {`
`88`	`88`	`"foo has been called {} time{}",`
`89`	`89`	`n,`
`90`	`90`	`if n == 1 { "" } else { "s" }`
`91`		`- )`
`92`		`- .ok();`
	`91`	`+ );`
`93`	`92`	`}`
`94`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,14 +42,14 @@ mod app {`
`42`	`42`	`let b = cx.shared.b;`
`43`	`43`	`let c = cx.shared.c;`
`44`	`44`
`45`		`- hprintln!("foo: a = {}, b = {}, c = {}", a, b, c).unwrap();`
	`45`	`+ hprintln!("foo: a = {}, b = {}, c = {}", a, b, c);`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`// De-structure-ing syntax`
`49`	`49`	`#[task(shared = [&a, &b, &c])]`
`50`	`50`	`fn bar(cx: bar::Context) {`
`51`	`51`	`let bar::SharedResources { a, b, c } = cx.shared;`
`52`	`52`
`53`		`- hprintln!("bar: a = {}, b = {}, c = {}", a, b, c).unwrap();`
	`53`	`+ hprintln!("bar: a = {}, b = {}, c = {}", a, b, c);`
`54`	`54`	`}`
`55`	`55`	`}`