Rust 在嵌入式领域的开发实战，涵盖 ARM 裸机编程与 RTOS 应用。内容包含开发环境搭建（交叉编译工具链、OpenOCD、GDB）、裸机项目创建（Cargo.toml、memory.x 配置）、GPIO 操作、串口通信及中断处理。重点讲解 RTIC 框架实现多任务调度、资源共享与中断管理。通过 STM32F411RE 开发板案例，演示温湿度传感器读取等实战项目。涉及内存管理、栈溢出处理、寄存器初始化及硬件调试优化方法。
cortex-m、cortex-m-rt 库进行 ARM 裸机开发，实现 GPIO 操作、串口通信、中断处理💡 三大核心难点：
core、alloc 库管理内存，避免内存泄漏cortex-m 库实现中断函数和临界区保护⚠️ 三大高频错误点：
嵌入式系统是一种以应用为中心、以计算机技术为基础、软件硬件可裁剪、适应应用系统对功能、可靠性、成本、体积、功耗严格要求的专用计算机系统。嵌入式系统的核心特点是：
嵌入式系统的架构通常分为以下几种：
Rust 作为一门系统编程语言，非常适合嵌入式开发，其优势包括：
使用 rustup 安装 ARM 和 RISC-V 的交叉编译工具链：
# 安装 ARM Cortex-M0/M3/M4 的交叉编译工具链
rustup target add thumbv6m-none-eabi
rustup target add thumbv7m-none-eabi
rustup target add thumbv7em-none-eabi
rustup target add thumbv8m.base-none-eabi
rustup target add thumbv8m.main-none-eabi
rustup target add thumbv8m.main-none-eabihf
# 安装 RISC-V 的交叉编译工具链
rustup target add riscv32imc-unknown-none-elf
rustup target add riscv64gc-unknown-none-elf
OpenOCD 是开源的调试器和编程器，支持多种调试接口（JTAG、SWD）。
⌨️ Ubuntu/Debian 安装 OpenOCD：
sudo apt-get install openocd
⌨️ Windows 安装 OpenOCD： 下载 OpenOCD 的 Windows 版本，解压后添加到系统 PATH 中。
GDB 是GNU 调试器，支持 ARM 和 RISC-V 架构的调试。
⌨️ Ubuntu/Debian 安装 ARM GDB：
sudo apt-get install gdb-multiarch
⌨️ Windows 安装 ARM GDB： 下载 ARM GDB 的 Windows 版本，解压后添加到系统 PATH 中。
安装以下 VS Code 扩展：
使用 cargo generate 创建一个新的 Rust 裸机项目：
# 安装 cargo generate
cargo install cargo-generate
# 使用 cortex-m-quickstart 模板创建项目
cargo generate --git https://github.com/rust-embedded/cortex-m-quickstart --name stm32f411re-demo
在 Cargo.toml 中添加依赖：
[dependencies]
cortex-m = "0.7"
cortex-m-rt = "0.7"
panic-halt = "0.2"
[dependencies.stm32f4xx-hal]
version = "0.18"
features = ["stm32f411", "rt"]
在 memory.x 文件中配置 Flash 和 RAM 的地址和大小：
/* Linker script for STM32F411RE Nucleo */
MEMORY {
FLASH : ORIGIN = 0x08000000, LENGTH = 512K
RAM : ORIGIN = 0x20000000, LENGTH = 128K
}
在 src/main.rs 文件中编写 LED 闪烁的代码：
#![no_std]
#![no_main]
use cortex_m_rt::entry;
use panic_halt as _;
use stm32f4xx_hal::gpio::*;
use stm32f4xx_hal::pac;
use stm32f4xx_hal::prelude::*;
use stm32f4xx_hal::timer::*;
#[entry]
fn main() -> ! {
// 获取硬件抽象层（HAL）
let dp = pac::Peripherals::take().unwrap();
let cp = cortex_m::Peripherals::take().unwrap();
// 配置系统时钟
let rcc = dp.RCC.constrain();
let clocks = rcc.cfgr.sysclk(84.MHz()).freeze();
// 配置 GPIO
let gpioc = dp.GPIOC.split();
let mut led = gpioc.pc13.into_push_pull_output();
// 配置定时器
let mut timer = dp.TIM2.timer(&clocks).start_ticker();
// 配置系统定时器（SysTick）
let mut systick = cp.SYST.counter_us(&clocks);
// LED 闪烁
loop {
led.toggle();
systick.delay(500_000); // 延迟 500ms
}
}
在 src/main.rs 文件中添加串口通信的代码：
use stm32f4xx_hal::serial::*;
#[entry]
fn main() -> ! {
// 获取硬件抽象层（HAL）
let dp = pac::Peripherals::take().unwrap();
let cp = cortex_m::Peripherals::take().unwrap();
// 配置系统时钟
let rcc = dp.RCC.constrain();
let clocks = rcc.cfgr.sysclk(84.MHz()).freeze();
// 配置 GPIO
let gpioa = dp.GPIOA.split();
let tx = gpioa.pa2.into_alternate();
let rx = gpioa.pa3.into_alternate();
// 配置串口
let mut serial = dp.USART2.serial((tx, rx), 9600.Bd(), &clocks).unwrap();
serial.listen(Event::Rxne);
// 发送数据
serial.write_str("Hello, Rust Embedded!\n").unwrap();
// 接收数据
loop {
if let Ok(byte) = nb::block!(serial.read()) {
serial.write(byte).unwrap();
}
}
}
使用 cargo build 命令编译项目：
# 编译为 ARM Cortex-M4 架构
cargo build --target thumbv7em-none-eabihf --release
使用 OpenOCD 烧录程序：
# 连接开发板
openocd -f interface/stlink.cfg -f target/stm32f4x.cfg
# 在另一个终端中使用 GDB 烧录
gdb-multiarch target/thumbv7em-none-eabihf/release/stm32f411re-demo
(gdb) target remote :3333
(gdb) monitor reset halt
(gdb) load
(gdb) monitor reset run
RTIC（Real-Time Interrupt-driven Concurrency）是Rust 社区开发的实时操作系统框架，它基于中断驱动的并发模型，支持：
resource 宏实现互斥访问interrupt 宏实现中断函数channel 宏实现任务间通信使用 cargo generate 创建一个新的 RTIC 项目：
cargo generate --git https://github.com/rtic-rs/cortex-m-quickstart --name rtic-demo
在 src/main.rs 文件中编写 RTIC 代码：
#![no_std]
#![no_main]
use panic_halt as _;
use rtic::app;
use stm32f4xx_hal::gpio::*;
use stm32f4xx_hal::pac;
use stm32f4xx_hal::prelude::*;
use stm32f4xx_hal::serial::*;
use stm32f4xx_hal::timer::*;
#[app(device = stm32f4xx_hal::pac, peripherals = true)]
const APP: () = {
struct Resources {
led: gpioc::PC13<Output<PushPull>>,
timer: Timer<pac::TIM2>,
serial: Serial<pac::USART2, (gpioa::PA2<Alternate<AF7>>, gpioa::PA3<Alternate<AF7>>), 9600>,
}
#[init]
fn init(cx: init::Context) -> init::LateResources {
// 获取硬件抽象层（HAL）
let dp = cx.device;
let cp = cx.core;
// 配置系统时钟
let rcc = dp.RCC.constrain();
let clocks = rcc.cfgr.sysclk(84.MHz()).freeze();
// 配置 GPIO
let gpioc = dp.GPIOC.split();
let led = gpioc.pc13.into_push_pull_output();
let gpioa = dp.GPIOA.split();
let tx = gpioa.pa2.into_alternate();
let rx = gpioa.pa3.into_alternate();
// 配置串口
let serial = dp.USART2.serial((tx, rx), 9600.Bd(), &clocks).unwrap();
serial.listen(Event::Rxne);
// 配置定时器
let timer = dp.TIM2.timer(&clocks).start_ticker();
// 发送初始化信息
serial.write_str("RTIC Demo Initialized!\n").unwrap();
init::LateResources { led, timer, serial }
}
#[task(binds = TIM2, resources = [led, timer])]
fn timer_interrupt(cx: timer_interrupt::Context) {
// 清除定时器中断标志
cx.resources.timer.clear_interrupt(TimerInterrupt::Update);
// 切换 LED 状态
cx.resources.led.toggle();
}
#[task(binds = USART2, resources = [serial])]
fn serial_interrupt(cx: serial_interrupt::Context) {
// 清除串口中断标志
cx.resources.serial.clear_interrupt(Event::Rxne);
// 接收数据
if let Ok(byte) = nb::block!(cx.resources.serial.read()) {
// 发送数据
cx.resources.serial.write(byte).unwrap();
}
}
};
💡 场景分析：需要使用 STM32F411RE Nucleo 板连接 DHT11 温湿度传感器，读取温湿度数据，并通过串口发送到电脑。
| STM32F411RE | DHT11 |
|---|---|
| 5V | VCC |
| GND | GND |
| PB12 | DATA |
在 src/main.rs 文件中添加温湿度传感器数据读取的代码：
#![no_std]
#![no_main]
use panic_halt as _;
use rtic::app;
use stm32f4xx_hal::gpio::*;
use stm32f4xx_hal::pac;
use stm32f4xx_hal::prelude::*;
use stm32f4xx_hal::serial::*;
use stm32f4xx_hal::timer::*;
// 定义 DHT11 传感器类型
struct DHT11 {
pin: gpiob::PB12<Input<Floating>>,
}
impl DHT11 {
// 初始化 DHT11 传感器
fn new(pin: gpiob::PB12<Input<Floating>>) -> Self {
DHT11 { pin }
}
// 读取温湿度数据
fn read(&mut self) -> Option<(u8, u8)> {
let mut data: [u8; 5] = [0; 5];
// 发送启动信号
let mut pin = self.pin.into_push_pull_output();
pin.set_low();
cortex_m::asm::delay(18000); // 延迟 18ms
pin.set_high();
cortex_m::asm::delay(30); // 延迟 30us
// 等待 DHT11 响应
let pin = pin.into_floating_input();
while pin.is_high() {}
while pin.is_low() {}
while pin.is_high() {}
// 读取数据
for i in 0..5 {
let mut byte = 0;
for j in 0..8 {
while pin.is_low() {}
cortex_m::asm::delay(40); // 延迟 40us
if pin.is_high() {
byte |= 1 << (7 - j);
}
while pin.is_high() {}
}
data[i] = byte;
}
// 校验数据
let checksum = data[0] + data[1] + data[2] + data[3];
if data[4] == checksum {
Some((data[0], data[2]))
} else {
None
}
}
}
#[app(device = stm32f4xx_hal::pac, peripherals = true)]
const APP: () = {
struct Resources {
dht11: DHT11,
serial: Serial<pac::USART2, (gpioa::PA2<Alternate<AF7>>, gpioa::PA3<Alternate<AF7>>), 9600>,
timer: Timer<pac::TIM3>,
}
#[init]
fn init(cx: init::Context) -> init::LateResources {
// 获取硬件抽象层（HAL）
let dp = cx.device;
let cp = cx.core;
// 配置系统时钟
let rcc = dp.RCC.constrain();
let clocks = rcc.cfgr.sysclk(84.MHz()).freeze();
// 配置 GPIO
let gpiob = dp.GPIOB.split();
let dht11 = DHT11::new(gpiob.pb12.into_floating_input());
let gpioa = dp.GPIOA.split();
let tx = gpioa.pa2.into_alternate();
let rx = gpioa.pa3.into_alternate();
// 配置串口
let serial = dp.USART2.serial((tx, rx), 9600.Bd(), &clocks).unwrap();
serial.listen(Event::Rxne);
// 配置定时器
let timer = dp.TIM3.timer(&clocks).start_ticker();
init::LateResources { dht11, serial, timer }
}
#[task(binds = TIM3, resources = [dht11, serial])]
fn timer_interrupt(cx: timer_interrupt::Context) {
// 清除定时器中断标志
cx.resources.timer.clear_interrupt(TimerInterrupt::Update);
// 读取温湿度数据
if let Some((temperature, humidity)) = cx.resources.dht11.read() {
// 发送温湿度数据
let message = format!("温度： {}°C, 湿度： {}%\n", temperature, humidity);
cx.resources.serial.write_str(&message).unwrap();
} else {
cx.resources.serial.write_str("读取温湿度数据失败\n").unwrap();
}
}
#[task(binds = USART2, resources = [serial])]
fn serial_interrupt(cx: serial_interrupt::Context) {
// 清除串口中断标志
cx.resources.serial.clear_interrupt(Event::Rxne);
// 接收数据
if let Ok(byte) = nb::block!(cx.resources.serial.read()) {
// 发送数据
cx.resources.serial.write(byte).unwrap();
}
}
};
问题现象：程序崩溃，调试器显示'HardFault'。
解决方案：
memory.x 文件中修改 RAM 的大小或调整链接器脚本alloc 库进行堆分配问题现象：硬件功能无法正常实现。
解决方案：
问题现象：I2C/SPI 通信时，数据传输错误。
解决方案：
✅ 理解了嵌入式开发基础：深入掌握了嵌入式系统的定义、特点、架构，对比了 Rust 与传统嵌入式开发语言的优势
✅ 搭建了 Rust 嵌入式开发环境：安装了交叉编译工具链、调试工具，配置了 VS Code 开发环境
✅ 掌握了 Rust 裸机编程：使用 cortex-m、cortex-m-rt 库进行 ARM 裸机开发，实现了 GPIO 操作、串口通信、中断处理
✅ 学习了 RTOS 开发：使用 RTIC 实现了多任务编程，理解了任务调度、资源共享、中断管理
✅ 实战了嵌入式项目：结合 STM32F4xx 系列开发板，实现了 LED 闪烁、温湿度传感器数据读取、串口通信
✅ 优化与调试：学习了 Rust 嵌入式代码的优化方法，使用 GDB/OpenOCD 进行硬件调试
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online