## 引言：C 语言的挑战者
嵌入式系统占据了计算设备的 98%——从汽车 ECU 到医疗设备，从智能表计到航天控制器。几十年来，C 和 C++ 主导了这一领域，但它们的内存安全漏洞也导致了无数关键系统的安全隐患。
Rust——一种提供内存安全保证的系统编程语言——正在嵌入式领域快速崛起。2023 年起，Rust 在嵌入式 Linux 基金会、Automotive (AUTOSAR) 联盟的推动下，正在从"有趣的尝试"变成"主流选择"。
## 嵌入式 Rust 的技术基石
### no_std 生态
Rust 嵌入式开发的核心是 `#[no_std]` 模式——不使用标准库（依赖 OS 的部分），仅使用 `core` 库：
```rust
#![no_std]
#![no_main]
use cortex_m_rt::entry;
#[entry]
fn main() -> ! {
// 裸机代码：直接操作寄存器
let dp = pac::Peripherals::take().unwrap();
dp.RB.port.modify(|r, w| w.pin_out().set_bit());
loop {}
}
```
关键概念：
- **PAC（Peripheral Access Crate）**：由 svd2rust 从 SVD 文件自动生成
- **HAL（Hardware Abstraction Layer）**：提供跨 MCU 的通用接口（embedded-hal 特质）
- **Board Crate**：具体开发板的引脚映射和时钟配置
### 内存安全在嵌入式中的意义
嵌入式系统中内存安全的意义远超桌面软件——系统往往要求运行数十年不重启：
| 安全威胁 | C/C++ 典型表现 | Rust 防护 |
|----------|---------------|-----------|
| Use-After-Free | 释放后仍通过指针访问 | 编译期所有权检查 |
| Buffer Overflow | 数组越界写入 | 切片（Slice）边界检查 |
| Data Race | 中断与主程序的数据竞争 | Send/Sync trait |
| Null Pointer | 空指针解引用 | Option |
| Stack Overflow | 大数组爆栈 | 形态分析 + 堆分配 |
### 中断处理模型
嵌入式编程的核心是中断——硬件事件触发执行回调：
```rust
#[cortex_m_rt::ext_interrupt]
fn TIM2() {
// 中断处理
static mut COUNTER: u32 = 0;
unsafe {
*COUNTER += 1;
}
// 清除中断标志
...
}
```
Rust 的 `static mut` 在中断场景中是 race condition 的温床。RTIC 框架通过类型安全的共享状态机制解决了这一问题。
## RTIC：Rust 的实时中断驱动框架
### 框架概述
RTIC（Real-Time Interrupt-driven Concurrency）是北欧 SysTe 实验室开发的零成本抽象 RTOS 框架。它基于以下原则：
1. **消息传递优先**：任务间通过消息通信，避免共享状态
2. **资源锁**：基于优先级的 ceiling protocol 实现无死锁共享
3. **软件任务 + 硬件任务**：硬件任务响应中断，软件任务被调度执行
### 架构模型
```
┌─────────────────────────┐
interrupts → │ Hardware Tasks ─────────────────→ respond (no queue)
│ (spawned from IRQs) │
├─────────────────────────┤
│ Software Tasks ─────────────→ execute at priority
│ (message-passing) │
├─────────────────────────┤
scheduling → │ Idle / Sleep ───────→ WFI/WFE
└─────────────────────────┘
```
### 任务调度
RTIC 的责任是：正确处理软件任务（sw task）的调度和执行顺序。
```rust
#[init]
fn init() -> SharedResources {
// 初始化硬件
}
#[task(binds = TIM2, priority = 2)]
fn timer(mut cx: timer::Context) {
// 硬件任务：响应中断
// 可以 spawn 软件任务
software_task::spawn().unwrap();
}
#[task(capacity = 4, priority = 1)]
fn software_task(cx: software_task::Context, data: u32) {
// 软件任务：执行逻辑
// 通过锁访问共享资源
cx.shared.counter.lock(|counter| {
*counter += data;
});
}
```
### 资源访问控制（Ceiling Protocol）
RTIC 使用 Immediate Ceiling Priority Protocol（ICPP）防止优先级反转：
```
共享资源 Counter 的 Priority Ceiling = max(所有访问该资源的任务优先级)
当任务获取资源时 → 任务优先级提升到 Ceiling
当任务释放资源 → 恢复原始优先级
```
编译期确保：只要软件任务未持有资源，高优先级任务不会被阻塞更长时间——这提供了确定性调度保障（优先考虑中断延迟）。
## Tock OS：基于 Rust 的嵌入式操作系统
### 架构设计
Tock OS 是 UC Berkeley 开发的嵌入式操作系统，使用 Rust 实现内核和 Capsule（驱动程序），C/C++ 实现应用（通过 Userland 隔离）。
内核使用 Rust 的 async/await 特性实现高效的事件驱动模型：
```rust
// Tock Capsule（内核模块）示例
pub struct SensorCapsule<'a, P: Photovoltaic> {
photovoltage: &'a P,
client: OptionalCell<&'a dyn hil::sensors::IlluminationClient>,
}
impl<'a, P: Photovoltaic> hil::sensors::Illumination<'a> for SensorCapsule<'a, P> {
fn read(&'a self, callback: &'a dyn Fn(u32)) {
// 异步读取光照强度
self.photovoltage.read_voltage(callback);
}
}
```
### 进程隔离
Tock 保护内核和应用程序通过内存保护单元（Memory Protection Unit）实现隔离：
```
┌──────────────┐ Privileged Mode
│ Tock Kernel │ (Rust, Capsules)
├──────────────┤ User Mode
│ Application │ (C/Rust/Assembly)
└──────────────┘
```
每个应用有独立的 Flash 和 SRAM 区域，MPU 在运行时执行隔离——即使应用崩溃或恶意，不会影响内核或其他应用。
### 异步运行时
Tock 的异步运行时（Futures）设计在 `#![no_std]` 环境中：
```rust
impl<'a> Future for SensorReadFuture<'a> {
type Output = u32;
fn poll(&mut self) -> Poll {
match self.sensor.try_read() {
Ok(value) => Poll::Ready(value),
Err(WouldBlock) => {
self.sensor.register_waker(self.waker);
Poll::Pending
}
}
}
}
```
无需操作系统调度，驱动直接使用 Rust async 的 poll 模型——这使得 Tock 内核极其轻量。
## 嵌入式 Rust 的工具链
### 构建环境
```bash
# 安装目标（以 ARM Cortex-M4 为例）
rustup target add thumbv7em-none-eabihf
# 安装 probe-rs（烧录和调试）
cargo install probe-rs --features=cli
# Cargo 构建
cargo build --release
```
### 调试工具
- **probe-rs**：开源探针框架，支持 JTAG/SWD
- **defmt**：嵌入式优化的日志框架（比 std::fmt 节省 10x 带宽）
- **embedded-hal-mock**：硬件接口的模拟测试
- **Renode**：开源仿真平台，支持多种嵌入式 SoC
| 功能 | 传统 C 工具 | Rust 等价物 |
|------|-----------|------------|
| 交叉编译 | arm-none-eabi-gcc | cargo + rustup target |
| 烧录 | openocd + gdb | probe-rs |
| 日志 | printf/ITM | defmt、rtt-target |
| Unity/Ceedling | 嵌入式测试 | embedded-test、cargo test |
## 实时性保证
### 嵌入式系统的实时分类
| 类型 | 违约后果 | 示例 | Rust 支持 |
|------|----------|------|-----------|
| Hard Real-Time | 灾难性 | 汽车制动、心脏起搏器 | 严格 no_std |
| Soft Real-Time | 体验下降 | 视频流、音频 | embedded + tokio? |
| Firm Real-Time | 结果作废 | 工业传感器采集 | 通用 |
### Rust 在 Hard Real-Time 中的挑战
Rust 的 panic 机制、动态内存（alloc）和中断都可能影响实时性：
1. **panic = abort**：`[profile.dev] panic = "abort"` 消除 unwind 开销
2. **静态内存预算**：使用 `static` 和编译期确定的缓冲区大小
3. **延迟中断禁用**：RTIC 只在最短临界区期间限制中断（微秒级）
## 工程实践与性能
### 性能对比：Rust vs C vs C++
| 指标 | C (GCC -O2) | C++20 | Rust |
|------|-------------|-------|------|
| 代码大小 | 1.0x | 1.1-1.3x | 0.9-1.1x |
| 执行速度 | 1.0x | 0.98-1.0x | 0.95-1.02x |
| 内存安全 | 手动检查 | 可选（ASan） | 编译期自动保证 |
| 延迟确定性 | 最高 | 高（需小心） | 较高（无 GC） |
| 开发效率 | 中 | 中高 | 高（类型系统指导） |
### Rust 开发区别于 C 的收益
1. **所有权系统**：编译期检测所有资源泄漏、重复释放、数据竞争
2. **trait 机制**：比宏和 void* 更安全的接口抽象
3. **泛型 + 单态化**：零开销抽象，编译时特化
4. **迭代器 + 闭包**：比手写循环更安全且通常更快（编译器可优化）
## 未来发展趋势
### Rust in Linux Kernel
2022 年，Linux 6.1 开始合并 Rust 支持——内核模块现在可以用 Rust 编写：
```rust
// 内核模块示例（简化）
module! {
type: WelcomeModule,
author: "YBB",
description: "Rust kernel module example",
license: "GPL",
}
struct WelcomeModule;
impl KernelModule for WelcomeModule {
fn init() -> Result {
pr_info!("Rust kernel module loaded!\n");
Ok(WelcomeModule)
}
}
impl Drop for WelcomeModule {
fn drop(&mut self) {
pr_info!("Rust kernel module unloaded!\n");
}
}
```
这标志着 Rust 在系统编程领域的"登顶"。
### 行业标准采纳
- **ISO 26262（汽车）**：Rust 正在被评估作为 ASIL-D 级别的候选语言
- **IEC 61508（工业）**：安全完整性等级评估中
- **MISRA C**：MISRA Rust Guidelines 草案已发布
- **AUTOSAR**：AUTOSAR 联盟研究 Rust 在汽车 ECU 中的应用
## 总结
Rust 在嵌入式领域的崛起不仅仅是语言替换，更是一种**工程范式的升级**：
- **RTIC** 让裸机编程从无序中断跳转到有序任务调度
- **Tock OS** 让应用隔离在资源受限的 MCU 上成为现实
- **所有权系统** 在编译期就消除了嵌入式开发中最危险的内存安全问题
- **async/await** 让事件驱动编程像同步代码一样清晰
嵌入式 Rust 的成熟还需要时间——HAL、驱动程序和认证工具链仍在建设中。但随着 Linux 内核接纳 Rust、行业标准开始跟进，嵌入式开发的新时代已经开启。
---
*本文由 YBB 自动化流水线发布*
发表评论 取消回复