mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2024-11-25 21:19:35 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update semihosting

Browse source
This commit is contained in:
Emil Fresk 2023-01-08 19:40:31 +01:00 committed by Henrik Tjäder
parent 9a67f00a30
commit ceaf3613d3
25 changed files with 88 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
examples/async-task-multiple-prios.rs
View file

@ -24,8 +24,8 @@ mod app {
struct Local {}
#[init]
fn init(cx: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
fn init(_: init::Context) -> (Shared, Local) {
hprintln!("init");
async_task1::spawn().ok();
async_task2::spawn().ok();
@ -51,8 +51,7 @@ mod app {
*a += 1;
*a
})
)
.ok();
);
}
#[task(priority = 1, shared = [a, b])]
@ -63,8 +62,7 @@ mod app {
*a += 1;
*a
})
)
.ok();
);
}
#[task(priority = 2, shared = [a, b])]
@ -75,8 +73,7 @@ mod app {
*a += 1;
*a
})
)
.ok();
);
}
#[task(priority = 2, shared = [a, b])]
@ -87,7 +84,6 @@ mod app {
*a += 1;
*a
})
)
.ok();
);
}
}

8
examples/async-task.rs
View file

@ -24,7 +24,7 @@ mod app {
#[init]
fn init(_cx: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
hprintln!("init");
async_task::spawn().unwrap();
async_task2::spawn().unwrap();
@ -44,18 +44,18 @@ mod app {
#[task(binds = UART1, shared = [a])]
fn hw_task(cx: hw_task::Context) {
let hw_task::SharedResources { a: _, .. } = cx.shared;
hprintln!("hello from hw").ok();
hprintln!("hello from hw");
}
#[task(shared = [a])]
async fn async_task(cx: async_task::Context) {
let async_task::SharedResources { a: _, .. } = cx.shared;
hprintln!("hello from async").ok();
hprintln!("hello from async");
}
#[task(priority = 2, shared = [a])]
async fn async_task2(cx: async_task2::Context) {
let async_task2::SharedResources { a: _, .. } = cx.shared;
hprintln!("hello from async2").ok();
hprintln!("hello from async2");
}
}

4
examples/big-struct-opt.rs
View file

@ -67,13 +67,13 @@ mod app {
fn uart0(mut cx: uart0::Context) {
cx.shared
.big_struct
.lock(|b| hprintln!("uart0 data:{:?}", &b.data[0..5]).unwrap());
.lock(|b| hprintln!("uart0 data:{:?}", &b.data[0..5]));
}
#[task(shared = [big_struct], priority = 2)]
async fn async_task(mut cx: async_task::Context) {
cx.shared
.big_struct
.lock(|b| hprintln!("async_task data:{:?}", &b.data[0..5]).unwrap());
.lock(|b| hprintln!("async_task data:{:?}", &b.data[0..5]));
}
}

7
examples/binds.rs
View file

@ -23,14 +23,14 @@ mod app {
fn init(_: init::Context) -> (Shared, Local) {
rtic::pend(Interrupt::UART0);
hprintln!("init").unwrap();
hprintln!("init");
(Shared {}, Local {})
}
#[idle]
fn idle(_: idle::Context) -> ! {
hprintln!("idle").unwrap();
hprintln!("idle");
rtic::pend(Interrupt::UART0);
@ -49,7 +49,6 @@ mod app {
"foo called {} time{}",
*cx.local.times,
if *cx.local.times > 1 { "s" } else { "" }
)
.unwrap();
);
}
}

53
examples/complex.rs
View file

@ -25,7 +25,7 @@ mod app {
#[init]
fn init(_: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
hprintln!("init");
(
Shared {
@ -39,31 +39,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
@ -81,9 +81,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])]
@ -95,19 +94,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])]
@ -119,13 +117,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");
}
}

4
examples/destructure.rs
View file

@ -43,7 +43,7 @@ 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
@ -51,6 +51,6 @@ mod app {
async 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);
}
}

6
examples/extern_binds.rs
View file

@ -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,14 +29,14 @@ mod app {
fn init(_: init::Context) -> (Shared, Local) {
rtic::pend(Interrupt::UART0);
hprintln!("init").unwrap();
hprintln!("init");
(Shared {}, Local {})
}
#[idle]
fn idle(_: idle::Context) -> ! {
hprintln!("idle").unwrap();
hprintln!("idle");
rtic::pend(Interrupt::UART0);

2
examples/extern_spawn.rs
View file

@ -12,7 +12,7 @@ use panic_semihosting as _;
// Free function implementing the spawnable task `foo`.
// Notice, you need to indicate an anonymous lifetime <'a_>
async fn foo(_c: app::foo::Context<'_>) {
hprintln!("foo").unwrap();
hprintln!("foo");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}

6
examples/generics.rs
View file

@ -32,7 +32,7 @@ mod app {
#[task(binds = UART0, shared = [shared], local = [state: u32 = 0])]
fn uart0(c: uart0::Context) {
hprintln!("UART0(STATE = {})", *c.local.state).unwrap();
hprintln!("UART0(STATE = {})", *c.local.state);
// second argument has type `shared::shared`
super::advance(c.local.state, c.shared.shared);
@ -44,7 +44,7 @@ mod app {
#[task(binds = UART1, priority = 2, shared = [shared], local = [state: u32 = 0])]
fn uart1(c: uart1::Context) {
hprintln!("UART1(STATE = {})", *c.local.state).unwrap();
hprintln!("UART1(STATE = {})", *c.local.state);
// second argument has type `shared::shared`
super::advance(c.local.state, c.shared.shared);
@ -61,5 +61,5 @@ fn advance(state: &mut u32, mut shared: impl Mutex<T = u32>) {
(old, *shared)
});
hprintln!("shared: {} -> {}", old, new).unwrap();
hprintln!("shared: {} -> {}", old, new);
}

7
examples/hardware.rs
View file

@ -24,7 +24,7 @@ mod app {
// `init` returns because interrupts are disabled
rtic::pend(Interrupt::UART0); // equivalent to NVIC::pend
hprintln!("init").unwrap();
hprintln!("init");
(Shared {}, Local {})
}
@ -33,7 +33,7 @@ mod app {
fn idle(_: idle::Context) -> ! {
// interrupts are enabled again; the `UART0` handler runs at this point
hprintln!("idle").unwrap();
hprintln!("idle");
rtic::pend(Interrupt::UART0);
@ -53,7 +53,6 @@ mod app {
"UART0 called {} time{}",
*cx.local.times,
if *cx.local.times > 1 { "s" } else { "" }
)
.unwrap();
);
}
}

4
examples/idle-wfi.rs
View file

@ -19,7 +19,7 @@ mod app {
#[init]
fn init(mut cx: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
hprintln!("init");
// Set the ARM SLEEPONEXIT bit to go to sleep after handling interrupts
// See https://developer.arm.com/docs/100737/0100/power-management/sleep-mode/sleep-on-exit-bit
@ -33,7 +33,7 @@ mod app {
// Locals in idle have lifetime 'static
let _x: &'static mut u32 = cx.local.x;
hprintln!("idle").unwrap();
hprintln!("idle");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator

4
examples/idle.rs
View file

@ -19,7 +19,7 @@ mod app {
#[init]
fn init(_: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
hprintln!("init");
(Shared {}, Local {})
}
@ -29,7 +29,7 @@ mod app {
// Locals in idle have lifetime 'static
let _x: &'static mut u32 = cx.local.x;
hprintln!("idle").unwrap();
hprintln!("idle");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator

2
examples/init.rs
View file

@ -32,7 +32,7 @@ mod app {
// to indicate that this is a critical section
let _cs_token: bare_metal::CriticalSection = cx.cs;
hprintln!("init").unwrap();
hprintln!("init");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator

6
examples/locals.rs
View file

@ -45,7 +45,7 @@ mod app {
let local_to_idle = cx.local.local_to_idle;
*local_to_idle += 1;
hprintln!("idle: local_to_idle = {}", local_to_idle).unwrap();
hprintln!("idle: local_to_idle = {}", local_to_idle);
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
@ -69,7 +69,7 @@ mod app {
// error: no `local_to_bar` field in `foo::LocalResources`
// cx.local.local_to_bar += 1;
hprintln!("foo: local_to_foo = {}", local_to_foo).unwrap();
hprintln!("foo: local_to_foo = {}", local_to_foo);
}
// `local_to_bar` can only be accessed from this context
@ -81,6 +81,6 @@ mod app {
// error: no `local_to_foo` field in `bar::LocalResources`
// cx.local.local_to_foo += 1;
hprintln!("bar: local_to_bar = {}", local_to_bar).unwrap();
hprintln!("bar: local_to_bar = {}", local_to_bar);
}
}

10
examples/lock.rs
View file

@ -30,7 +30,7 @@ mod app {
// when omitted priority is assumed to be `1`
#[task(shared = [shared])]
async fn foo(mut c: foo::Context) {
hprintln!("A").unwrap();
hprintln!("A");
// the lower priority task requires a critical section to access the data
c.shared.shared.lock(|shared| {
@ -40,7 +40,7 @@ mod app {
// bar will *not* run right now due to the critical section
bar::spawn().unwrap();
hprintln!("B - shared = {}", *shared).unwrap();
hprintln!("B - shared = {}", *shared);
// baz does not contend for `shared` so it's allowed to run now
baz::spawn().unwrap();
@ -48,7 +48,7 @@ mod app {
// critical section is over: bar can now start
hprintln!("E").unwrap();
hprintln!("E");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
@ -62,11 +62,11 @@ mod app {
*shared
});
hprintln!("D - shared = {}", shared).unwrap();
hprintln!("D - shared = {}", shared);
}
#[task(priority = 3)]
async fn baz(_: baz::Context) {
hprintln!("C").unwrap();
hprintln!("C");
}
}

2
examples/multilock.rs
View file

@ -48,7 +48,7 @@ mod app {
*s2 += 1;
*s3 += 1;
hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", *s1, *s2, *s3).unwrap();
hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", *s1, *s2, *s3);
});
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator

6
examples/not-sync.rs
View file

@ -32,7 +32,7 @@ mod app {
#[init]
fn init(_: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
hprintln!("init");
foo::spawn().unwrap();
bar::spawn().unwrap();
@ -56,12 +56,12 @@ mod app {
#[task(shared = [&shared])]
async fn foo(c: foo::Context) {
let shared: &NotSync = c.shared.shared;
hprintln!("foo a {}", shared.data).unwrap();
hprintln!("foo a {}", shared.data);
}
#[task(shared = [&shared])]
async fn bar(c: bar::Context) {
let shared: &NotSync = c.shared.shared;
hprintln!("foo a {}", shared.data).unwrap();
hprintln!("foo a {}", shared.data);
}
}

4
examples/only-shared-access.rs
View file

@ -31,13 +31,13 @@ mod app {
#[task(shared = [&key])]
async fn foo(cx: foo::Context) {
let key: &u32 = cx.shared.key;
hprintln!("foo(key = {:#x})", key).unwrap();
hprintln!("foo(key = {:#x})", key);
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
#[task(priority = 2, shared = [&key])]
async fn bar(cx: bar::Context) {
hprintln!("bar(key = {:#x})", cx.shared.key).unwrap();
hprintln!("bar(key = {:#x})", cx.shared.key);
}
}

10
examples/preempt.rs
View file

@ -26,21 +26,21 @@ mod app {
#[task(priority = 1)]
async fn foo(_: foo::Context) {
hprintln!("foo - start").unwrap();
hprintln!("foo - start");
baz::spawn().unwrap();
hprintln!("foo - end").unwrap();
hprintln!("foo - end");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
#[task(priority = 2)]
async fn bar(_: bar::Context) {
hprintln!(" bar").unwrap();
hprintln!(" bar");
}
#[task(priority = 2)]
async fn baz(_: baz::Context) {
hprintln!(" baz - start").unwrap();
hprintln!(" baz - start");
bar::spawn().unwrap();
hprintln!(" baz - end").unwrap();
hprintln!(" baz - end");
}
}

2
examples/ramfunc.rs
View file

@ -33,7 +33,7 @@ mod app {
#[inline(never)]
#[task]
async fn foo(_: foo::Context) {
hprintln!("foo").unwrap();
hprintln!("foo");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}

4
examples/resource-user-struct.rs
View file

@ -55,7 +55,7 @@ mod app {
*shared
});
hprintln!("UART0: shared = {}", shared).unwrap();
hprintln!("UART0: shared = {}", shared);
}
// `shared` can be accessed from this context
@ -66,6 +66,6 @@ mod app {
*shared
});
hprintln!("UART1: shared = {}", shared).unwrap();
hprintln!("UART1: shared = {}", shared);
}
}

2
examples/shared.rs
View file

@ -34,7 +34,7 @@ mod app {
fn idle(mut c: idle::Context) -> ! {
loop {
if let Some(byte) = c.shared.c.lock(|c| c.dequeue()) {
hprintln!("received message: {}", byte).unwrap();
hprintln!("received message: {}", byte);
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
} else {

4
examples/spawn.rs
View file

@ -20,7 +20,7 @@ mod app {
#[init]
fn init(_: init::Context) -> (Shared, Local) {
hprintln!("init").unwrap();
hprintln!("init");
foo::spawn().unwrap();
(Shared {}, Local {})
@ -28,7 +28,7 @@ mod app {
#[task]
async fn foo(_: foo::Context) {
hprintln!("foo").unwrap();
hprintln!("foo");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}

2
examples/static.rs
View file

@ -38,7 +38,7 @@ mod app {
loop {
// Lock-free access to the same underlying queue!
if let Some(data) = c.local.c.dequeue() {
hprintln!("received message: {}", data).unwrap();
hprintln!("received message: {}", data);
// Run foo until data
if data == 3 {

10
examples/task.rs
View file

@ -27,31 +27,31 @@ mod app {
#[task]
async fn foo(_: foo::Context) {
hprintln!("foo - start").unwrap();
hprintln!("foo - start");
// spawns `bar` onto the task scheduler
// `foo` and `bar` have the same priority so `bar` will not run until
// after `foo` terminates
bar::spawn().unwrap();
hprintln!("foo - middle").unwrap();
hprintln!("foo - middle");
// spawns `baz` onto the task scheduler
// `baz` has higher priority than `foo` so it immediately preempts `foo`
baz::spawn().unwrap();
hprintln!("foo - end").unwrap();
hprintln!("foo - end");
}
#[task]
async fn bar(_: bar::Context) {
hprintln!("bar").unwrap();
hprintln!("bar");
debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
}
#[task(priority = 2)]
async fn baz(_: baz::Context) {
hprintln!("baz").unwrap();
hprintln!("baz");
}
}