Real-Time Interrupt-driven Concurrency

#[init(local = [memory: [u8; 512] = [0; 512]])]

fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {

// Increase the capacity of the memory pool by ~4

P::grow(cx.local.memory);

rtic::pend(Interrupt::I2C0);

(Shared {}, Local {}, init::Monotonics())

}

#[task(binds = I2C0, priority = 2)]

fn i2c0(_: i2c0::Context) {

// claim a memory block, initialize it and ..

let x = P::alloc().unwrap().init([0u8; 128]);

// .. send it to the `foo` task

foo::spawn(x).ok().unwrap();

// send another block to the task `bar`

bar::spawn(P::alloc().unwrap().init([0u8; 128]))

.ok()

.unwrap();

}

#[task]

fn foo(_: foo::Context, x: Box

) {

hprintln!("foo({:?})", x.as_ptr()).unwrap();

// explicitly return the block to the pool

drop(x);

debug::exit(debug::EXIT_SUCCESS);

}

#[task(priority = 2)]

fn bar(_: bar::Context, x: Box

) {

hprintln!("bar({:?})", x.as_ptr()).unwrap();

// this is done automatically so we can omit the call to `drop`

// drop(x);

}

}

}

$ cargo run --example pool

bar(0x2000008c)

foo(0x20000110)

Инспектирование раскрываемого кода

#[rtic::app] - это процедурный макрос, который создает код. Если по какой-то причине вам нужно увидеть код, сгенерированный этим макросом, у вас есть два пути:

Вы можете изучить файл rtic-expansion.rs внутри папки target. Этот файл содержит элемент #[rtic::app] в раскрытом виде (не всю вашу программу!) из последней сборки (с помощью cargo build или cargo check) RTIC программы. Раскрытый код не отформатирован по-умолчанию, но вы можете запустить rustfmt на нем перед тем, как читать.

$ cargo build --example foo

$ rustfmt target/rtic-expansion.rs

$ tail target/rtic-expansion.rs

#[doc = r" Implementation details"]

mod app {

#[doc = r" Always include the device crate which contains the vector table"]

use lm3s6965 as _;

#[no_mangle]

unsafe extern "C" fn main() -> ! {

rtic::export::interrupt::disable();

let mut core: rtic::export::Peripherals = core::mem::transmute(());

core.SCB.scr.modify(|r| r | 1 << 1);

rtic::export::interrupt::enable();

loop {

rtic::export::wfi()

}

}

}

Или, вы можете использовать подкоманду cargo-expand. Она раскроет все макросы, включая атрибут #[rtic::app], и модули в вашем крейте и напечатает вывод в консоль.

$ # создаст такой же вывод, как выше

$ cargo expand --example smallest | tail

Деструктуризация ресурса

Если задача требует нескольких ресурсов, разбиение структуры ресурсов может улучшить читабельность. Вот два примера того, как это можно сделать:

#![allow(unused)]

fn main() {

//! examples/destructure.rs

#![deny(unsafe_code)]

#![deny(warnings)]

#![no_main]

#![no_std]

use panic_semihosting as _;

#[rtic::app(device = lm3s6965)]

mod app {

use cortex_m_semihosting::hprintln;

use lm3s6965::Interrupt;

#[shared]

struct Shared {

// Some resources to work with

a: u32,

b: u32,

c: u32,

}

#[local]

struct Local {}

#[init]

fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {

rtic::pend(Interrupt::UART0);

rtic::pend(Interrupt::UART1);