From 1b4b006bab7ee05e403a4fc48ae751d037f95b1a Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sun, 21 Apr 2019 20:10:40 +0200 Subject: [PATCH] update examples --- examples/baseline.rs | 19 ++++++----- examples/binds.rs | 9 +++--- examples/capacity.rs | 21 ++++++------- examples/cfg.rs | 13 ++++---- examples/generics.rs | 18 +++++------ examples/idle.rs | 7 ++--- examples/init.rs | 9 +++--- examples/interrupt.rs | 9 +++--- examples/late.rs | 13 ++++---- examples/lock.rs | 17 +++++----- examples/message.rs | 19 ++++++----- examples/not-send.rs | 20 ++++++------ examples/not-sync.rs | 13 ++++---- examples/periodic.rs | 14 ++++----- examples/ramfunc.rs | 13 ++++---- examples/resource.rs | 19 ++++++----- examples/schedule.rs | 14 ++++----- examples/shared-with-init.rs | 8 ++--- examples/singleton.rs | 61 ------------------------------------ examples/smallest.rs | 2 +- examples/static.rs | 13 ++++---- examples/task.rs | 17 +++++----- examples/types.rs | 46 +++++++++++++-------------- 23 files changed, 159 insertions(+), 235 deletions(-) delete mode 100644 examples/singleton.rs diff --git a/examples/baseline.rs b/examples/baseline.rs index fdf368383d..d743107dc1 100644 --- a/examples/baseline.rs +++ b/examples/baseline.rs @@ -9,24 +9,23 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; // NOTE: does NOT properly work on QEMU -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init(spawn = [foo])] - fn init() { - hprintln!("init(baseline = {:?})", start).unwrap(); + fn init(c: init::Context) { + hprintln!("init(baseline = {:?})", c.start).unwrap(); // `foo` inherits the baseline of `init`: `Instant(0)` - spawn.foo().unwrap(); + c.spawn.foo().unwrap(); } #[task(schedule = [foo])] - fn foo() { + fn foo(c: foo::Context) { static mut ONCE: bool = true; - hprintln!("foo(baseline = {:?})", scheduled).unwrap(); + hprintln!("foo(baseline = {:?})", c.scheduled).unwrap(); if *ONCE { *ONCE = false; @@ -38,11 +37,11 @@ const APP: () = { } #[interrupt(spawn = [foo])] - fn UART0() { - hprintln!("UART0(baseline = {:?})", start).unwrap(); + fn UART0(c: UART0::Context) { + hprintln!("UART0(baseline = {:?})", c.start).unwrap(); // `foo` inherits the baseline of `UART0`: its `start` time - spawn.foo().unwrap(); + c.spawn.foo().unwrap(); } extern "C" { diff --git a/examples/binds.rs b/examples/binds.rs index a8b386fb7e..3d2d9b541b 100644 --- a/examples/binds.rs +++ b/examples/binds.rs @@ -9,20 +9,19 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; // `examples/interrupt.rs` rewritten to use `binds` -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init] - fn init() { + fn init(_: init::Context) { rtfm::pend(Interrupt::UART0); hprintln!("init").unwrap(); } #[idle] - fn idle() -> ! { + fn idle(_: idle::Context) -> ! { hprintln!("idle").unwrap(); rtfm::pend(Interrupt::UART0); @@ -33,7 +32,7 @@ const APP: () = { } #[interrupt(binds = UART0)] - fn foo() { + fn foo(_: foo::Context) { static mut TIMES: u32 = 0; *TIMES += 1; diff --git a/examples/capacity.rs b/examples/capacity.rs index a7132ba0f4..07edd9b8e1 100644 --- a/examples/capacity.rs +++ b/examples/capacity.rs @@ -9,32 +9,31 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init] - fn init() { + fn init(_: init::Context) { rtfm::pend(Interrupt::UART0); } #[interrupt(spawn = [foo, bar])] - fn UART0() { - spawn.foo(0).unwrap(); - spawn.foo(1).unwrap(); - spawn.foo(2).unwrap(); - spawn.foo(3).unwrap(); + fn UART0(c: UART0::Context) { + c.spawn.foo(0).unwrap(); + c.spawn.foo(1).unwrap(); + c.spawn.foo(2).unwrap(); + c.spawn.foo(3).unwrap(); - spawn.bar().unwrap(); + c.spawn.bar().unwrap(); } #[task(capacity = 4)] - fn foo(x: u32) { + fn foo(_: foo::Context, x: u32) { hprintln!("foo({})", x).unwrap(); } #[task] - fn bar() { + fn bar(_: bar::Context) { hprintln!("bar").unwrap(); debug::exit(debug::EXIT_SUCCESS); diff --git a/examples/cfg.rs b/examples/cfg.rs index 3f4ca90431..03f9dbdcb2 100644 --- a/examples/cfg.rs +++ b/examples/cfg.rs @@ -9,25 +9,24 @@ extern crate panic_semihosting; #[cfg(debug_assertions)] use cortex_m_semihosting::hprintln; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[cfg(debug_assertions)] // <- `true` when using the `dev` profile static mut COUNT: u32 = 0; #[init] - fn init() { + fn init(_: init::Context) { // .. } #[task(priority = 3, resources = [COUNT], spawn = [log])] - fn foo() { + fn foo(c: foo::Context) { #[cfg(debug_assertions)] { - *resources.COUNT += 1; + *c.resources.COUNT += 1; - spawn.log(*resources.COUNT).ok(); + c.spawn.log(*c.resources.COUNT).ok(); } // this wouldn't compile in `release` mode @@ -38,7 +37,7 @@ const APP: () = { #[cfg(debug_assertions)] #[task] - fn log(n: u32) { + fn log(_: log::Context, n: u32) { hprintln!( "foo has been called {} time{}", n, diff --git a/examples/generics.rs b/examples/generics.rs index c8ce839351..e624da39cf 100644 --- a/examples/generics.rs +++ b/examples/generics.rs @@ -9,25 +9,25 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::{app, Mutex}; +use rtfm::Mutex; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { static mut SHARED: u32 = 0; #[init] - fn init() { + fn init(_: init::Context) { rtfm::pend(Interrupt::UART0); rtfm::pend(Interrupt::UART1); } #[interrupt(resources = [SHARED])] - fn UART0() { + fn UART0(c: UART0::Context) { static mut STATE: u32 = 0; hprintln!("UART0(STATE = {})", *STATE).unwrap(); - advance(STATE, resources.SHARED); + advance(STATE, c.resources.SHARED); rtfm::pend(Interrupt::UART1); @@ -35,17 +35,17 @@ const APP: () = { } #[interrupt(priority = 2, resources = [SHARED])] - fn UART1() { + fn UART1(mut c: UART1::Context) { static mut STATE: u32 = 0; hprintln!("UART1(STATE = {})", *STATE).unwrap(); // just to show that `SHARED` can be accessed directly and .. - *resources.SHARED += 0; + *c.resources.SHARED += 0; // .. also through a (no-op) `lock` - resources.SHARED.lock(|shared| *shared += 0); + c.resources.SHARED.lock(|shared| *shared += 0); - advance(STATE, resources.SHARED); + advance(STATE, c.resources.SHARED); } }; diff --git a/examples/idle.rs b/examples/idle.rs index 1f21a37f4a..d10cc43ed0 100644 --- a/examples/idle.rs +++ b/examples/idle.rs @@ -8,17 +8,16 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init] - fn init() { + fn init(_: init::Context) { hprintln!("init").unwrap(); } #[idle] - fn idle() -> ! { + fn idle(_: idle::Context) -> ! { static mut X: u32 = 0; // Safe access to local `static mut` variable diff --git a/examples/init.rs b/examples/init.rs index be6cfe3eb3..df687794a8 100644 --- a/examples/init.rs +++ b/examples/init.rs @@ -8,19 +8,18 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init] - fn init() { + fn init(c: init::Context) { static mut X: u32 = 0; // Cortex-M peripherals - let _core: rtfm::Peripherals = core; + let _core: rtfm::Peripherals = c.core; // Device specific peripherals - let _device: lm3s6965::Peripherals = device; + let _device: lm3s6965::Peripherals = c.device; // Safe access to local `static mut` variable let _x: &'static mut u32 = X; diff --git a/examples/interrupt.rs b/examples/interrupt.rs index 3c669d9ef2..dd6efa0df5 100644 --- a/examples/interrupt.rs +++ b/examples/interrupt.rs @@ -9,12 +9,11 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init] - fn init() { + fn init(_: init::Context) { // Pends the UART0 interrupt but its handler won't run until *after* // `init` returns because interrupts are disabled rtfm::pend(Interrupt::UART0); @@ -23,7 +22,7 @@ const APP: () = { } #[idle] - fn idle() -> ! { + fn idle(_: idle::Context) -> ! { // interrupts are enabled again; the `UART0` handler runs at this point hprintln!("idle").unwrap(); @@ -36,7 +35,7 @@ const APP: () = { } #[interrupt] - fn UART0() { + fn UART0(_: UART0::Context) { static mut TIMES: u32 = 0; // Safe access to local `static mut` variable diff --git a/examples/late.rs b/examples/late.rs index 622008a7fe..0074fb3233 100644 --- a/examples/late.rs +++ b/examples/late.rs @@ -13,16 +13,15 @@ use heapless::{ spsc::{Consumer, Producer, Queue}, }; use lm3s6965::Interrupt; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { // Late resources static mut P: Producer<'static, u32, U4> = (); static mut C: Consumer<'static, u32, U4> = (); #[init] - fn init() -> init::LateResources { + fn init(_: init::Context) -> init::LateResources { // NOTE: we use `Option` here to work around the lack of // a stable `const` constructor static mut Q: Option> = None; @@ -35,9 +34,9 @@ const APP: () = { } #[idle(resources = [C])] - fn idle() -> ! { + fn idle(c: idle::Context) -> ! { loop { - if let Some(byte) = resources.C.dequeue() { + if let Some(byte) = c.resources.C.dequeue() { hprintln!("received message: {}", byte).unwrap(); debug::exit(debug::EXIT_SUCCESS); @@ -48,7 +47,7 @@ const APP: () = { } #[interrupt(resources = [P])] - fn UART0() { - resources.P.enqueue(42).unwrap(); + fn UART0(c: UART0::Context) { + c.resources.P.enqueue(42).unwrap(); } }; diff --git a/examples/lock.rs b/examples/lock.rs index 4ca862e316..814c73640f 100644 --- a/examples/lock.rs +++ b/examples/lock.rs @@ -9,24 +9,23 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { static mut SHARED: u32 = 0; #[init] - fn init() { + fn init(_: init::Context) { rtfm::pend(Interrupt::GPIOA); } // when omitted priority is assumed to be `1` #[interrupt(resources = [SHARED])] - fn GPIOA() { + fn GPIOA(mut c: GPIOA::Context) { hprintln!("A").unwrap(); // the lower priority task requires a critical section to access the data - resources.SHARED.lock(|shared| { + c.resources.SHARED.lock(|shared| { // data can only be modified within this critical section (closure) *shared += 1; @@ -47,15 +46,15 @@ const APP: () = { } #[interrupt(priority = 2, resources = [SHARED])] - fn GPIOB() { + fn GPIOB(mut c: GPIOB::Context) { // the higher priority task does *not* need a critical section - *resources.SHARED += 1; + *c.resources.SHARED += 1; - hprintln!("D - SHARED = {}", *resources.SHARED).unwrap(); + hprintln!("D - SHARED = {}", *c.resources.SHARED).unwrap(); } #[interrupt(priority = 3)] - fn GPIOC() { + fn GPIOC(_: GPIOC::Context) { hprintln!("C").unwrap(); } }; diff --git a/examples/message.rs b/examples/message.rs index b5d68a607b..1fd3b9d4c5 100644 --- a/examples/message.rs +++ b/examples/message.rs @@ -8,41 +8,40 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init(spawn = [foo])] - fn init() { - spawn.foo(/* no message */).unwrap(); + fn init(c: init::Context) { + c.spawn.foo(/* no message */).unwrap(); } #[task(spawn = [bar])] - fn foo() { + fn foo(c: foo::Context) { static mut COUNT: u32 = 0; hprintln!("foo").unwrap(); - spawn.bar(*COUNT).unwrap(); + c.spawn.bar(*COUNT).unwrap(); *COUNT += 1; } #[task(spawn = [baz])] - fn bar(x: u32) { + fn bar(c: bar::Context, x: u32) { hprintln!("bar({})", x).unwrap(); - spawn.baz(x + 1, x + 2).unwrap(); + c.spawn.baz(x + 1, x + 2).unwrap(); } #[task(spawn = [foo])] - fn baz(x: u32, y: u32) { + fn baz(c: baz::Context, x: u32, y: u32) { hprintln!("baz({}, {})", x, y).unwrap(); if x + y > 4 { debug::exit(debug::EXIT_SUCCESS); } - spawn.foo().unwrap(); + c.spawn.foo().unwrap(); } extern "C" { diff --git a/examples/not-send.rs b/examples/not-send.rs index be78c332ff..c1b6bcddf8 100644 --- a/examples/not-send.rs +++ b/examples/not-send.rs @@ -21,32 +21,32 @@ const APP: () = { static mut SHARED: Option = None; #[init(spawn = [baz, quux])] - fn init() { - spawn.baz().unwrap(); - spawn.quux().unwrap(); + fn init(c: init::Context) { + c.spawn.baz().unwrap(); + c.spawn.quux().unwrap(); } #[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() { + fn baz(mut 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() { + fn quux(mut 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); } diff --git a/examples/not-sync.rs b/examples/not-sync.rs index d94e0a0467..bc71406571 100644 --- a/examples/not-sync.rs +++ b/examples/not-sync.rs @@ -10,29 +10,28 @@ extern crate panic_halt; use core::marker::PhantomData; use cortex_m_semihosting::debug; -use rtfm::app; pub struct NotSync { _0: PhantomData<*const ()>, } -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { static SHARED: NotSync = NotSync { _0: PhantomData }; #[init] - fn init() { + fn init(_: init::Context) { debug::exit(debug::EXIT_SUCCESS); } #[task(resources = [SHARED])] - fn foo() { - let _: &NotSync = resources.SHARED; + fn foo(c: foo::Context) { + let _: &NotSync = c.resources.SHARED; } #[task(resources = [SHARED])] - fn bar() { - let _: &NotSync = resources.SHARED; + fn bar(c: bar::Context) { + let _: &NotSync = c.resources.SHARED; } extern "C" { diff --git a/examples/periodic.rs b/examples/periodic.rs index ba2b4933df..f784118367 100644 --- a/examples/periodic.rs +++ b/examples/periodic.rs @@ -8,24 +8,24 @@ extern crate panic_semihosting; use cortex_m_semihosting::hprintln; -use rtfm::{app, Instant}; +use rtfm::Instant; const PERIOD: u32 = 8_000_000; // NOTE: does NOT work on QEMU! -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init(schedule = [foo])] - fn init() { - schedule.foo(Instant::now() + PERIOD.cycles()).unwrap(); + fn init(c: init::Context) { + c.schedule.foo(Instant::now() + PERIOD.cycles()).unwrap(); } #[task(schedule = [foo])] - fn foo() { + fn foo(c: foo::Context) { let now = Instant::now(); - hprintln!("foo(scheduled = {:?}, now = {:?})", scheduled, now).unwrap(); + hprintln!("foo(scheduled = {:?}, now = {:?})", c.scheduled, now).unwrap(); - schedule.foo(scheduled + PERIOD.cycles()).unwrap(); + c.schedule.foo(c.scheduled + PERIOD.cycles()).unwrap(); } extern "C" { diff --git a/examples/ramfunc.rs b/examples/ramfunc.rs index 37ea82a77e..4b0d69c793 100644 --- a/examples/ramfunc.rs +++ b/examples/ramfunc.rs @@ -8,18 +8,17 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init(spawn = [bar])] - fn init() { - spawn.bar().unwrap(); + fn init(c: init::Context) { + c.spawn.bar().unwrap(); } #[inline(never)] #[task] - fn foo() { + fn foo(_: foo::Context) { hprintln!("foo").unwrap(); debug::exit(debug::EXIT_SUCCESS); @@ -29,8 +28,8 @@ const APP: () = { #[inline(never)] #[link_section = ".data.bar"] #[task(priority = 2, spawn = [foo])] - fn bar() { - spawn.foo().unwrap(); + fn bar(c: bar::Context) { + c.spawn.foo().unwrap(); } extern "C" { diff --git a/examples/resource.rs b/examples/resource.rs index 5ddab9e8da..06bdf395ae 100644 --- a/examples/resource.rs +++ b/examples/resource.rs @@ -9,21 +9,20 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { // A resource static mut SHARED: u32 = 0; #[init] - fn init() { + fn init(_: init::Context) { rtfm::pend(Interrupt::UART0); rtfm::pend(Interrupt::UART1); } #[idle] - fn idle() -> ! { + fn idle(_: idle::Context) -> ! { debug::exit(debug::EXIT_SUCCESS); // error: `SHARED` can't be accessed from this context @@ -34,17 +33,17 @@ const APP: () = { // `SHARED` can be access from this context #[interrupt(resources = [SHARED])] - fn UART0() { - *resources.SHARED += 1; + fn UART0(mut c: UART0::Context) { + *c.resources.SHARED += 1; - hprintln!("UART0: SHARED = {}", resources.SHARED).unwrap(); + hprintln!("UART0: SHARED = {}", c.resources.SHARED).unwrap(); } // `SHARED` can be access from this context #[interrupt(resources = [SHARED])] - fn UART1() { - *resources.SHARED += 1; + fn UART1(mut c: UART1::Context) { + *c.resources.SHARED += 1; - hprintln!("UART1: SHARED = {}", resources.SHARED).unwrap(); + hprintln!("UART1: SHARED = {}", c.resources.SHARED).unwrap(); } }; diff --git a/examples/schedule.rs b/examples/schedule.rs index fd63347308..eaafb4c947 100644 --- a/examples/schedule.rs +++ b/examples/schedule.rs @@ -8,31 +8,31 @@ extern crate panic_semihosting; use cortex_m_semihosting::hprintln; -use rtfm::{app, Instant}; +use rtfm::Instant; // NOTE: does NOT work on QEMU! -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init(schedule = [foo, bar])] - fn init() { + fn init(c: init::Context) { let now = Instant::now(); hprintln!("init @ {:?}", now).unwrap(); // Schedule `foo` to run 8e6 cycles (clock cycles) in the future - schedule.foo(now + 8_000_000.cycles()).unwrap(); + c.schedule.foo(now + 8_000_000.cycles()).unwrap(); // Schedule `bar` to run 4e6 cycles in the future - schedule.bar(now + 4_000_000.cycles()).unwrap(); + c.schedule.bar(now + 4_000_000.cycles()).unwrap(); } #[task] - fn foo() { + fn foo(_: foo::Context) { hprintln!("foo @ {:?}", Instant::now()).unwrap(); } #[task] - fn bar() { + fn bar(_: bar::Context) { hprintln!("bar @ {:?}", Instant::now()).unwrap(); } diff --git a/examples/shared-with-init.rs b/examples/shared-with-init.rs index 5ddd2cc3d9..0fb9191cbd 100644 --- a/examples/shared-with-init.rs +++ b/examples/shared-with-init.rs @@ -18,17 +18,17 @@ const APP: () = { static mut SHARED: Option = None; #[init(resources = [SHARED])] - fn init() { + fn init(c: init::Context) { // this `message` will be sent to task `UART0` let message = MustBeSend; - *resources.SHARED = Some(message); + *c.resources.SHARED = Some(message); rtfm::pend(Interrupt::UART0); } #[interrupt(resources = [SHARED])] - fn UART0() { - if let Some(message) = resources.SHARED.take() { + fn UART0(c: UART0::Context) { + if let Some(message) = c.resources.SHARED.take() { // `message` has been received drop(message); diff --git a/examples/singleton.rs b/examples/singleton.rs deleted file mode 100644 index 9e48e54121..0000000000 --- a/examples/singleton.rs +++ /dev/null @@ -1,61 +0,0 @@ -//! examples/singleton.rs - -#![deny(unsafe_code)] -#![deny(warnings)] -#![no_main] -#![no_std] - -extern crate panic_semihosting; - -use alloc_singleton::stable::pool::{Box, Pool}; -use cortex_m_semihosting::{debug, hprintln}; -use lm3s6965::Interrupt; -use rtfm::app; - -#[app(device = lm3s6965)] -const APP: () = { - #[Singleton(Send)] - static mut M: [u32; 2] = [0; 2]; - - static mut P: Pool = (); - - #[init(resources = [M])] - fn init() -> init::LateResources { - rtfm::pend(Interrupt::I2C0); - - init::LateResources { - P: Pool::new(resources.M), - } - } - - #[interrupt( - priority = 2, - resources = [P], - spawn = [foo, bar], - )] - fn I2C0() { - spawn.foo(resources.P.alloc(1).unwrap()).unwrap(); - spawn.bar(resources.P.alloc(2).unwrap()).unwrap(); - } - - #[task(resources = [P])] - fn foo(x: Box) { - hprintln!("foo({})", x).unwrap(); - - resources.P.lock(|p| p.dealloc(x)); - - debug::exit(debug::EXIT_SUCCESS); - } - - #[task(priority = 2, resources = [P])] - fn bar(x: Box) { - hprintln!("bar({})", x).unwrap(); - - resources.P.dealloc(x); - } - - extern "C" { - fn UART0(); - fn UART1(); - } -}; diff --git a/examples/smallest.rs b/examples/smallest.rs index e4d86be9c9..c153716805 100644 --- a/examples/smallest.rs +++ b/examples/smallest.rs @@ -13,5 +13,5 @@ use rtfm::app; #[app(device = lm3s6965)] const APP: () = { #[init] - fn init() {} + fn init(_: init::Context) {} }; diff --git a/examples/static.rs b/examples/static.rs index 0309b68163..2e3b5b4197 100644 --- a/examples/static.rs +++ b/examples/static.rs @@ -9,14 +9,13 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; use lm3s6965::Interrupt; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { static KEY: u32 = (); #[init] - fn init() -> init::LateResources { + fn init(_: init::Context) -> init::LateResources { rtfm::pend(Interrupt::UART0); rtfm::pend(Interrupt::UART1); @@ -24,14 +23,14 @@ const APP: () = { } #[interrupt(resources = [KEY])] - fn UART0() { - hprintln!("UART0(KEY = {:#x})", resources.KEY).unwrap(); + fn UART0(c: UART0::Context) { + hprintln!("UART0(KEY = {:#x})", c.resources.KEY).unwrap(); debug::exit(debug::EXIT_SUCCESS); } #[interrupt(priority = 2, resources = [KEY])] - fn UART1() { - hprintln!("UART1(KEY = {:#x})", resources.KEY).unwrap(); + fn UART1(c: UART1::Context) { + hprintln!("UART1(KEY = {:#x})", c.resources.KEY).unwrap(); } }; diff --git a/examples/task.rs b/examples/task.rs index 4f168bb814..5bb32acb73 100644 --- a/examples/task.rs +++ b/examples/task.rs @@ -8,38 +8,37 @@ extern crate panic_semihosting; use cortex_m_semihosting::{debug, hprintln}; -use rtfm::app; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { #[init(spawn = [foo])] - fn init() { - spawn.foo().unwrap(); + fn init(c: init::Context) { + c.spawn.foo().unwrap(); } #[task(spawn = [bar, baz])] - fn foo() { + fn foo(c: foo::Context) { hprintln!("foo").unwrap(); // spawns `bar` onto the task scheduler // `foo` and `bar` have the same priority so `bar` will not run until // after `foo` terminates - spawn.bar().unwrap(); + c.spawn.bar().unwrap(); // spawns `baz` onto the task scheduler // `baz` has higher priority than `foo` so it immediately preempts `foo` - spawn.baz().unwrap(); + c.spawn.baz().unwrap(); } #[task] - fn bar() { + fn bar(_: bar::Context) { hprintln!("bar").unwrap(); debug::exit(debug::EXIT_SUCCESS); } #[task(priority = 2)] - fn baz() { + fn baz(_: baz::Context) { hprintln!("baz").unwrap(); } diff --git a/examples/types.rs b/examples/types.rs index c1b8cd6923..c3dd89ca4c 100644 --- a/examples/types.rs +++ b/examples/types.rs @@ -8,45 +8,45 @@ extern crate panic_semihosting; use cortex_m_semihosting::debug; -use rtfm::{app, Exclusive, Instant}; +use rtfm::{Exclusive, Instant}; -#[app(device = lm3s6965)] +#[rtfm::app(device = lm3s6965)] const APP: () = { static mut SHARED: u32 = 0; #[init(schedule = [foo], spawn = [foo])] - fn init() { - let _: Instant = start; - let _: rtfm::Peripherals = core; - let _: lm3s6965::Peripherals = device; - let _: init::Schedule = schedule; - let _: init::Spawn = spawn; + fn init(c: init::Context) { + let _: Instant = c.start; + let _: rtfm::Peripherals = c.core; + let _: lm3s6965::Peripherals = c.device; + let _: init::Schedule = c.schedule; + let _: init::Spawn = c.spawn; debug::exit(debug::EXIT_SUCCESS); } #[exception(schedule = [foo], spawn = [foo])] - fn SVCall() { - let _: Instant = start; - let _: SVCall::Schedule = schedule; - let _: SVCall::Spawn = spawn; + fn SVCall(c: SVCall::Context) { + let _: Instant = c.start; + let _: SVCall::Schedule = c.schedule; + let _: SVCall::Spawn = c.spawn; } #[interrupt(resources = [SHARED], schedule = [foo], spawn = [foo])] - fn UART0() { - let _: Instant = start; - let _: resources::SHARED = resources.SHARED; - let _: UART0::Schedule = schedule; - let _: UART0::Spawn = spawn; + fn UART0(c: UART0::Context) { + let _: Instant = c.start; + let _: resources::SHARED = c.resources.SHARED; + let _: UART0::Schedule = c.schedule; + let _: UART0::Spawn = c.spawn; } #[task(priority = 2, resources = [SHARED], schedule = [foo], spawn = [foo])] - fn foo() { - let _: Instant = scheduled; - let _: Exclusive = resources.SHARED; - let _: foo::Resources = resources; - let _: foo::Schedule = schedule; - let _: foo::Spawn = spawn; + fn foo(c: foo::Context) { + let _: Instant = c.scheduled; + let _: Exclusive = c.resources.SHARED; + let _: foo::Resources = c.resources; + let _: foo::Schedule = c.schedule; + let _: foo::Spawn = c.spawn; } extern "C" {