Real-Time Interrupt-driven Concurrency — страница 10 из 23

mod app {
use cortex_m_semihosting::{debug, hprintln};

#[shared]
struct Shared {}

#[local]
struct Local {}

#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();

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

#[inline(never)]
#[task]
fn foo(_: foo::Context) {
hprintln!("foo").unwrap();

debug::exit(debug::EXIT_SUCCESS);
}

// run this task from RAM
#[inline(never)]
#[link_section = ".data.bar"]
#[task(priority = 2)]
fn bar(_: bar::Context) {
foo::spawn().unwrap();
}
}
}

Запуск этой программы создаст ожидаемый вывод.

$ cargo run --example ramfunc
foo

Можно посмотреть на вывод cargo-nm, чтобы убедиться, что bar расположен в ОЗУ (0x2000_0000), тогда как foo расположен во Flash (0x0000_0000).

$ cargo nm --example ramfunc --release | grep ' foo::'
00000162 t ramfunc::foo::h30e7789b08c08e19
$ cargo nm --example ramfunc --release | grep ' bar::'
20000000 t ramfunc::bar::h9d6714fe5a3b0c89

Обходной путь для быстрой передачи сообщений

Передача сообщений всегда вызывает копирование от отправителя в статическую переменную, а затем из статической переменной получателю. Таким образом, при передаче большого буфера, например [u8; 128], передача сообщения вызывает два дорогих вызова memcpy. Чтобы минимизировать накладные расходы на передачу сообщения, можно использовать обходной путь: вместо передачи буфера по значению, можно передавать владеющий указатель на буфер.

Можно использовать глобальный аллокатор, чтобы реализовать данный трюк (alloc::Box, alloc::Rc, и т.п.), либо использовать статически аллоцируемый пул памяти, например heapless::Pool.

Здесь приведен пример использования heapless::Pool для "упаковки" буфера из 128 байт.

#![allow(unused)]
fn main() {
//! examples/pool.rs

#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]

use heapless::{
pool,
pool::singleton::{Box, Pool},
};
use panic_semihosting as _;
use rtic::app;

// Declare a pool of 128-byte memory blocks
pool!(P: [u8; 128]);

#[app(device = lm3s6965, dispatchers = [SSI0, QEI0])]
mod app {
use crate::{Box, Pool};
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;

// Import the memory pool into scope
use super::P;

#[shared]
struct Shared {}

#[local]
struct Local {}

#[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