mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2025-02-17 13:58:38 +01:00
Code Issues Projects Releases Packages Wiki Activity

use new cortex_m_semihosting::hprintln macro

Browse source
This commit is contained in:
Jorge Aparicio 2018-11-04 19:57:39 +01:00
parent 22d758ddac
commit a279218295
17 changed files with 56 additions and 217 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -42,7 +42,7 @@ owned-singleton = "0.1.0"
[dev-dependencies] [dev-dependencies]
alloc-singleton = "0.1.0" alloc-singleton = "0.1.0"
cortex-m-semihosting = "0.3.1" cortex-m-semihosting = "0.3.2"
lm3s6965 = "0.1.3" lm3s6965 = "0.1.3"
panic-halt = "0.2.0" panic-halt = "0.2.0"

18
examples/baseline.rs
View file

@ -7,26 +7,16 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
// NOTE: does NOT properly work on QEMU // NOTE: does NOT properly work on QEMU
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init(spawn = [foo])] #[init(spawn = [foo])]
fn init() { fn init() {
println!("init(baseline = {:?})", start); hprintln!("init(baseline = {:?})", start).unwrap();
// `foo` inherits the baseline of `init`: `Instant(0)` // `foo` inherits the baseline of `init`: `Instant(0)`
spawn.foo().unwrap(); spawn.foo().unwrap();
@ -36,7 +26,7 @@ const APP: () = {
fn foo() { fn foo() {
static mut ONCE: bool = true; static mut ONCE: bool = true;
println!("foo(baseline = {:?})", scheduled); hprintln!("foo(baseline = {:?})", scheduled).unwrap();
if *ONCE { if *ONCE {
*ONCE = false; *ONCE = false;
@ -49,7 +39,7 @@ const APP: () = {
#[interrupt(spawn = [foo])] #[interrupt(spawn = [foo])]
fn UART0() { fn UART0() {
println!("UART0(baseline = {:?})", start); hprintln!("UART0(baseline = {:?})", start).unwrap();
// `foo` inherits the baseline of `UART0`: its `start` time // `foo` inherits the baseline of `UART0`: its `start` time
spawn.foo().unwrap(); spawn.foo().unwrap();

16
examples/capacity.rs
View file

@ -7,20 +7,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init] #[init]
@ -40,12 +30,12 @@ const APP: () = {
#[task(capacity = 4)] #[task(capacity = 4)]
fn foo(x: u32) { fn foo(x: u32) {
println!("foo({})", x); hprintln!("foo({})", x).unwrap();
} }
#[task] #[task]
fn bar() { fn bar() {
println!("bar"); hprintln!("bar").unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} }

20
examples/generics.rs
View file

@ -7,22 +7,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::{app, Mutex}; use rtfm::{app, Mutex};
// NOTE: This convenience macro will appear in all the other examples and
// will always look the same
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
static mut SHARED: u32 = 0; static mut SHARED: u32 = 0;
@ -37,7 +25,7 @@ const APP: () = {
fn UART0() { fn UART0() {
static mut STATE: u32 = 0; static mut STATE: u32 = 0;
println!("UART0(STATE = {})", *STATE); hprintln!("UART0(STATE = {})", *STATE).unwrap();
advance(STATE, resources.SHARED); advance(STATE, resources.SHARED);
@ -50,7 +38,7 @@ const APP: () = {
fn UART1() { fn UART1() {
static mut STATE: u32 = 0; static mut STATE: u32 = 0;
println!("UART1(STATE = {})", *STATE); hprintln!("UART1(STATE = {})", *STATE).unwrap();
// just to show that `SHARED` can be accessed directly and .. // just to show that `SHARED` can be accessed directly and ..
*resources.SHARED += 0; *resources.SHARED += 0;
@ -70,5 +58,5 @@ fn advance(state: &mut u32, mut shared: impl Mutex<T = u32>) {
(old, *shared) (old, *shared)
}); });
println!("SHARED: {} -> {}", old, new); hprintln!("SHARED: {} -> {}", old, new).unwrap();
} }

16
examples/idle.rs
View file

@ -7,24 +7,14 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init] #[init]
fn init() { fn init() {
println!("init"); hprintln!("init").unwrap();
} }
#[idle] #[idle]
@ -34,7 +24,7 @@ const APP: () = {
// Safe access to local `static mut` variable // Safe access to local `static mut` variable
let _x: &'static mut u32 = X; let _x: &'static mut u32 = X;
println!("idle"); hprintln!("idle").unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);

16
examples/init.rs
View file

@ -7,21 +7,9 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use rtfm::app; use rtfm::app;
// NOTE: This convenience macro will appear in all the other examples and
// will always look the same
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init] #[init]
@ -37,7 +25,7 @@ const APP: () = {
// Safe access to local `static mut` variable // Safe access to local `static mut` variable
let _x: &'static mut u32 = X; let _x: &'static mut u32 = X;
println!("init"); hprintln!("init").unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} }

21
examples/interrupt.rs
View file

@ -7,20 +7,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init] #[init]
@ -29,14 +19,14 @@ const APP: () = {
// `init` returns because interrupts are disabled // `init` returns because interrupts are disabled
rtfm::pend(Interrupt::UART0); rtfm::pend(Interrupt::UART0);
println!("init"); hprintln!("init").unwrap();
} }
#[idle] #[idle]
fn idle() -> ! { fn idle() -> ! {
// interrupts are enabled again; the `UART0` handler runs at this point // interrupts are enabled again; the `UART0` handler runs at this point
println!("idle"); hprintln!("idle").unwrap();
rtfm::pend(Interrupt::UART0); rtfm::pend(Interrupt::UART0);
@ -52,10 +42,11 @@ const APP: () = {
// Safe access to local `static mut` variable // Safe access to local `static mut` variable
*TIMES += 1; *TIMES += 1;
println!( hprintln!(
"UART0 called {} time{}", "UART0 called {} time{}",
*TIMES, *TIMES,
if *TIMES > 1 { "s" } else { "" } if *TIMES > 1 { "s" } else { "" }
); )
.unwrap();
} }
}; };

14
examples/late.rs
View file

@ -7,7 +7,7 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use heapless::{ use heapless::{
consts::*, consts::*,
spsc::{Consumer, Producer, Queue}, spsc::{Consumer, Producer, Queue},
@ -15,16 +15,6 @@ use heapless::{
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
// Late resources // Late resources
@ -49,7 +39,7 @@ const APP: () = {
fn idle() -> ! { fn idle() -> ! {
loop { loop {
if let Some(byte) = resources.C.dequeue() { if let Some(byte) = resources.C.dequeue() {
println!("received message: {}", byte); hprintln!("received message: {}", byte).unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} else { } else {

22
examples/lock.rs
View file

@ -7,20 +7,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
static mut SHARED: u32 = 0; static mut SHARED: u32 = 0;
@ -33,7 +23,7 @@ const APP: () = {
// when omitted priority is assumed to be `1` // when omitted priority is assumed to be `1`
#[interrupt(resources = [SHARED])] #[interrupt(resources = [SHARED])]
fn GPIOA() { fn GPIOA() {
println!("A"); hprintln!("A").unwrap();
// the lower priority task requires a critical section to access the data // the lower priority task requires a critical section to access the data
resources.SHARED.lock(|shared| { resources.SHARED.lock(|shared| {
@ -43,7 +33,7 @@ const APP: () = {
// GPIOB will *not* run right now due to the critical section // GPIOB will *not* run right now due to the critical section
rtfm::pend(Interrupt::GPIOB); rtfm::pend(Interrupt::GPIOB);
println!("B - SHARED = {}", *shared); hprintln!("B - SHARED = {}", *shared).unwrap();
// GPIOC does not contend for `SHARED` so it's allowed to run now // GPIOC does not contend for `SHARED` so it's allowed to run now
rtfm::pend(Interrupt::GPIOC); rtfm::pend(Interrupt::GPIOC);
@ -51,7 +41,7 @@ const APP: () = {
// critical section is over: GPIOB can now start // critical section is over: GPIOB can now start
println!("E"); hprintln!("E").unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} }
@ -61,11 +51,11 @@ const APP: () = {
// the higher priority task does *not* need a critical section // the higher priority task does *not* need a critical section
*resources.SHARED += 1; *resources.SHARED += 1;
println!("D - SHARED = {}", *resources.SHARED); hprintln!("D - SHARED = {}", *resources.SHARED).unwrap();
} }
#[interrupt(priority = 3)] #[interrupt(priority = 3)]
fn GPIOC() { fn GPIOC() {
println!("C"); hprintln!("C").unwrap();
} }
}; };

18
examples/message.rs
View file

@ -7,19 +7,9 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init(spawn = [foo])] #[init(spawn = [foo])]
@ -31,7 +21,7 @@ const APP: () = {
fn foo() { fn foo() {
static mut COUNT: u32 = 0; static mut COUNT: u32 = 0;
println!("foo"); hprintln!("foo").unwrap();
spawn.bar(*COUNT).unwrap(); spawn.bar(*COUNT).unwrap();
*COUNT += 1; *COUNT += 1;
@ -39,14 +29,14 @@ const APP: () = {
#[task(spawn = [baz])] #[task(spawn = [baz])]
fn bar(x: u32) { fn bar(x: u32) {
println!("bar({})", x); hprintln!("bar({})", x).unwrap();
spawn.baz(x + 1, x + 2).unwrap(); spawn.baz(x + 1, x + 2).unwrap();
} }
#[task(spawn = [foo])] #[task(spawn = [foo])]
fn baz(x: u32, y: u32) { fn baz(x: u32, y: u32) {
println!("baz({}, {})", x, y); hprintln!("baz({}, {})", x, y).unwrap();
if x + y > 4 { if x + y > 4 {
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);

13
examples/periodic.rs
View file

@ -7,18 +7,9 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::hprintln;
use rtfm::{app, Instant}; use rtfm::{app, Instant};
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
const PERIOD: u32 = 8_000_000; const PERIOD: u32 = 8_000_000;
// NOTE: does NOT work on QEMU! // NOTE: does NOT work on QEMU!
@ -32,7 +23,7 @@ const APP: () = {
#[task(schedule = [foo])] #[task(schedule = [foo])]
fn foo() { fn foo() {
let now = Instant::now(); let now = Instant::now();
println!("foo(scheduled = {:?}, now = {:?})", scheduled, now); hprintln!("foo(scheduled = {:?}, now = {:?})", scheduled, now).unwrap();
schedule.foo(scheduled + PERIOD.cycles()).unwrap(); schedule.foo(scheduled + PERIOD.cycles()).unwrap();
} }

14
examples/ramfunc.rs
View file

@ -7,19 +7,9 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init(spawn = [bar])] #[init(spawn = [bar])]
@ -30,7 +20,7 @@ const APP: () = {
#[inline(never)] #[inline(never)]
#[task] #[task]
fn foo() { fn foo() {
println!("foo"); hprintln!("foo").unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} }

16
examples/resource.rs
View file

@ -7,20 +7,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
// A resource // A resource
@ -47,7 +37,7 @@ const APP: () = {
fn UART0() { fn UART0() {
*resources.SHARED += 1; *resources.SHARED += 1;
println!("UART0: SHARED = {}", resources.SHARED); hprintln!("UART0: SHARED = {}", resources.SHARED).unwrap();
} }
// `SHARED` can be access from this context // `SHARED` can be access from this context
@ -55,6 +45,6 @@ const APP: () = {
fn UART1() { fn UART1() {
*resources.SHARED += 1; *resources.SHARED += 1;
println!("UART1: SHARED = {}", resources.SHARED); hprintln!("UART1: SHARED = {}", resources.SHARED).unwrap();
} }
}; };

17
examples/schedule.rs
View file

@ -7,18 +7,9 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::hprintln;
use rtfm::{app, Instant}; use rtfm::{app, Instant};
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
// NOTE: does NOT work on QEMU! // NOTE: does NOT work on QEMU!
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
@ -26,7 +17,7 @@ const APP: () = {
fn init() { fn init() {
let now = Instant::now(); let now = Instant::now();
println!("init @ {:?}", now); hprintln!("init @ {:?}", now).unwrap();
// Schedule `foo` to run 8e6 cycles (clock cycles) in the future // Schedule `foo` to run 8e6 cycles (clock cycles) in the future
schedule.foo(now + 8_000_000.cycles()).unwrap(); schedule.foo(now + 8_000_000.cycles()).unwrap();
@ -37,12 +28,12 @@ const APP: () = {
#[task] #[task]
fn foo() { fn foo() {
println!("foo @ {:?}", Instant::now()); hprintln!("foo @ {:?}", Instant::now()).unwrap();
} }
#[task] #[task]
fn bar() { fn bar() {
println!("bar @ {:?}", Instant::now()); hprintln!("bar @ {:?}", Instant::now()).unwrap();
} }
extern "C" { extern "C" {

16
examples/singleton.rs
View file

@ -8,20 +8,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use alloc_singleton::stable::pool::{Box, Pool}; use alloc_singleton::stable::pool::{Box, Pool};
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[Singleton(Send)] #[Singleton(Send)]
@ -48,7 +38,7 @@ const APP: () = {
#[task(resources = [P])] #[task(resources = [P])]
fn foo(x: Box<M>) { fn foo(x: Box<M>) {
println!("foo({})", x); hprintln!("foo({})", x).unwrap();
resources.P.lock(|p| p.dealloc(x)); resources.P.lock(|p| p.dealloc(x));
@ -57,7 +47,7 @@ const APP: () = {
#[task(priority = 2, resources = [P])] #[task(priority = 2, resources = [P])]
fn bar(x: Box<M>) { fn bar(x: Box<M>) {
println!("bar({})", x); hprintln!("bar({})", x).unwrap();
resources.P.dealloc(x); resources.P.dealloc(x);
} }

16
examples/static.rs
View file

@ -7,20 +7,10 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt; use lm3s6965::Interrupt;
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
static KEY: u32 = (); static KEY: u32 = ();
@ -35,13 +25,13 @@ const APP: () = {
#[interrupt(resources = [KEY])] #[interrupt(resources = [KEY])]
fn UART0() { fn UART0() {
println!("UART0(KEY = {:#x})", resources.KEY); hprintln!("UART0(KEY = {:#x})", resources.KEY).unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} }
#[interrupt(priority = 2, resources = [KEY])] #[interrupt(priority = 2, resources = [KEY])]
fn UART1() { fn UART1() {
println!("UART1(KEY = {:#x})", resources.KEY); hprintln!("UART1(KEY = {:#x})", resources.KEY).unwrap();
} }
}; };

18
examples/task.rs
View file

@ -7,19 +7,9 @@
extern crate panic_semihosting; extern crate panic_semihosting;
use cortex_m_semihosting::debug; use cortex_m_semihosting::{debug, hprintln};
use rtfm::app; use rtfm::app;
macro_rules! println {
($($tt:tt)*) => {
if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
use core::fmt::Write;
writeln!(stdout, $($tt)*).ok();
}
};
}
#[app(device = lm3s6965)] #[app(device = lm3s6965)]
const APP: () = { const APP: () = {
#[init(spawn = [foo])] #[init(spawn = [foo])]
@ -29,7 +19,7 @@ const APP: () = {
#[task(spawn = [bar, baz])] #[task(spawn = [bar, baz])]
fn foo() { fn foo() {
println!("foo"); hprintln!("foo").unwrap();
// spawns `bar` onto the task scheduler // spawns `bar` onto the task scheduler
// `foo` and `bar` have the same priority so `bar` will not run until // `foo` and `bar` have the same priority so `bar` will not run until
@ -43,14 +33,14 @@ const APP: () = {
#[task] #[task]
fn bar() { fn bar() {
println!("bar"); hprintln!("bar").unwrap();
debug::exit(debug::EXIT_SUCCESS); debug::exit(debug::EXIT_SUCCESS);
} }
#[task(priority = 2)] #[task(priority = 2)]
fn baz() { fn baz() {
println!("baz"); hprintln!("baz").unwrap();
} }
// Interrupt handlers used to dispatch software tasks // Interrupt handlers used to dispatch software tasks