1 files changed, 30 insertions, 20 deletions

diff --git a/examples/not-send.rs b/examples/not-send.rs
index be78c332..18071fc5 100644
--- a/examples/not-send.rs
+++ b/examples/not-send.rs
@@ -5,54 +5,64 @@
 #![no_main]
 #![no_std]
 
-extern crate panic_halt;
-
 use core::marker::PhantomData;
 
 use cortex_m_semihosting::debug;
-use rtfm::app;
+use panic_halt as _;
+use rtic::app;
 
 pub struct NotSend {
     _0: PhantomData<*const ()>,
 }
 
 #[app(device = lm3s6965)]
-const APP: () = {
-    static mut SHARED: Option<NotSend> = None;
+mod app {
+    use super::NotSend;
+
+    #[resources]
+    struct Resources {
+        #[init(None)]
+        shared: Option<NotSend>,
+    }
 
     #[init(spawn = [baz, quux])]
-    fn init() {
-        spawn.baz().unwrap();
-        spawn.quux().unwrap();
+    fn init(c: init::Context) -> init::LateResources {
+        c.spawn.baz().unwrap();
+        c.spawn.quux().unwrap();
+
+        init::LateResources {}
     }
 
     #[task(spawn = [bar])]
-    fn foo() {
+    fn foo(c: foo::Context) {
         // scenario 1: message passed to task that runs at the same priority
-        spawn.bar(NotSend { _0: PhantomData }).ok();
+        c.spawn.bar(NotSend { _0: PhantomData }).ok();
     }
 
     #[task]
-    fn bar(_x: NotSend) {
+    fn bar(_: bar::Context, _x: NotSend) {
         // scenario 1
     }
 
-    #[task(priority = 2, resources = [SHARED])]
-    fn baz() {
+    #[task(priority = 2, resources = [shared])]
+    fn baz(c: baz::Context) {
         // scenario 2: resource shared between tasks that run at the same priority
-        *resources.SHARED = Some(NotSend { _0: PhantomData });
+        *c.resources.shared = Some(NotSend { _0: PhantomData });
     }
 
-    #[task(priority = 2, resources = [SHARED])]
-    fn quux() {
+    #[task(priority = 2, resources = [shared])]
+    fn quux(c: quux::Context) {
         // scenario 2
-        let _not_send = resources.SHARED.take().unwrap();
+        let _not_send = c.resources.shared.take().unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
 
+    // RTIC requires that unused interrupts are declared in an extern block when
+    // using software tasks; these free interrupts will be used to dispatch the
+    // software tasks.
     extern "C" {
-        fn UART0();
-        fn UART1();
+        fn SSI0();
+        fn QEI0();
     }
-};
+}