King - 个人技术博客

引言

Rust的零成本抽象和内存安全特性使其成为嵌入式开发的理想选择，特别是在资源受限的环境中。

在嵌入式系统开发中，代码的性能、可靠性和资源效率至关重要。Rust语言通过其独特的所有权系统和零成本抽象，提供了一种安全且高效的方式来开发嵌入式应用。本文将详细探讨Rust在嵌入式开发中的应用。

no_std环境

#![no_std]
#![no_main]
 
use core::panic::PanicInfo;
 
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}
 
#[no_mangle]
pub extern "C" fn _start() -> ! {
    loop {}
}

在嵌入式开发中，我们通常需要在没有标准库支持的环境下工作。no_std环境去除了对操作系统的依赖，使得代码可以直接运行在裸机上：

移除标准库依赖
- 避免对操作系统功能的依赖
- 减少二进制文件大小
- 降低内存占用
使用core库替代std
- 提供基本的语言特性
- 不依赖操作系统
- 支持基础数据类型和算法
需要自定义panic处理
- 处理运行时错误
- 适应资源受限环境
- 提供错误恢复机制
需要定义入口点
- 直接控制程序启动
- 初始化硬件
- 配置系统状态

硬件抽象层（HAL）

use embedded_hal::digital::v2::OutputPin;
use stm32f4xx_hal::{pac, prelude::*};
 
#[entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    let gpioa = dp.GPIOA.split();
    
    // 配置LED引脚
    let mut led = gpioa.pa5.into_push_pull_output();
    
    loop {
        led.set_high().unwrap();
        delay(1000);
        led.set_low().unwrap();
        delay(1000);
    }
}

硬件抽象层为不同的嵌入式平台提供了统一的编程接口，使得代码更容易移植和维护：

硬件无关的抽象接口
类型安全的外设访问
可移植性好
代码复用性高

中断处理

use cortex_m::interrupt::free;
use stm32f4xx_hal::interrupt;
 
static mut COUNTER: u32 = 0;
 
#[interrupt]
fn TIM2() {
    free(|_| {
        unsafe {
            COUNTER = COUNTER.wrapping_add(1);
        }
    });
}
 
#[entry]
fn main() -> ! {
    // 配置定时器中断
    let dp = pac::Peripherals::take().unwrap();
    let mut timer = dp.TIM2;
    
    timer.enable_interrupt();
    
    loop {
        // 主循环
    }
}

中断处理的关键点：

使用#[interrupt]属性
安全地访问全局状态
优先级管理
临界区保护

外设访问

use embedded_hal::spi::{Mode, Phase, Polarity};
use stm32f4xx_hal::{pac, prelude::*, spi::Spi};
 
#[entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    let gpioa = dp.GPIOA.split();
    
    // 配置SPI引脚
    let sck = gpioa.pa5;
    let miso = gpioa.pa6;
    let mosi = gpioa.pa7;
    
    // 配置SPI
    let mode = Mode {
        polarity: Polarity::IdleLow,
        phase: Phase::CaptureOnFirstTransition,
    };
    
    let mut spi = Spi::spi1(
        dp.SPI1,
        (sck, miso, mosi),
        mode,
        1.mhz(),
        clocks,
    );
    
    // 使用SPI通信
    let mut buffer = [0u8; 4];
    spi.transfer(&mut buffer).unwrap();
}

实时系统集成

use rtic::app;
 
#[app(device = stm32f4xx_hal::pac, peripherals = true)]
const APP: () = {
    #[shared]
    struct Shared {
        led: Led,
    }
 
    #[local]
    struct Local {
        timer: Timer<TIM2>,
    }
 
    #[init]
    fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
        let mut timer = ctx.device.TIM2.counter_hz(&clocks);
        timer.start(1.hz()).unwrap();
        timer.listen(Event::Update);
        
        (Shared { led }, Local { timer }, init::Monotonics())
    }
 
    #[task(binds = TIM2, shared = [led])]
    fn timer_tick(ctx: timer_tick::Context) {
        ctx.shared.led.lock(|led| {
            led.toggle().unwrap();
        });
    }
};

RTIC 框架特性：

声明式任务调度
优先级抢占
资源管理
零开销抽象

调试工具

use defmt::{debug, error, info, warn};
use panic_probe as _;
use probe_run::{self, config::Config};
 
#[entry]
fn main() -> ! {
    info!("程序启动");
    
    if let Err(e) = initialize_hardware() {
        error!("硬件初始化失败: {}", e);
        panic!();
    }
    
    // 配置调试选项
    let config = Config {
        chip: "STM32F401",
        probe_selector: Some("*"),
        ..Default::default()
    };
    
    // 启动调试会话
    match probe_run::run_with_config(config) {
        Ok(_) => info!("调试会话结束"),
        Err(e) => error!("调试失败: {}", e),
    }
    
    loop {
        // 主循环中的调试信息
        debug!("系统状态: {:?}", get_system_status());
        warn!("内存使用: {}%", get_memory_usage());
        
        // 条件断点示例
        if get_temperature() > 80.0 {
            error!("温度过高！");
            break;
        }
        
        cortex_m::asm::delay(1_000_000);
    }
}
 
// 调试辅助函数
fn get_system_status() -> SystemStatus {
    SystemStatus {
        uptime: get_uptime(),
        cpu_load: get_cpu_load(),
        active_tasks: get_active_tasks(),
    }
}
 
#[derive(Debug)]
struct SystemStatus {
    uptime: u32,
    cpu_load: f32,
    active_tasks: u8,
}
 
// RTOS集成调试
#[cfg(feature = "rtos-debug")]
mod rtos_debug {
    use defmt::Format;
    
    #[derive(Format)]
    struct TaskInfo {
        name: &'static str,
        stack_usage: u32,
        last_runtime: u32,
    }
    
    pub fn print_task_stats() {
        let tasks = get_task_list();
        for task in tasks {
            info!(
                "任务 {}: 栈使用 {}字节, 最近运行时间 {}ms",
                task.name,
                task.stack_usage,
                task.last_runtime
            );
        }
    }
}
    
    debug!("配置完成");
    
    loop {
        warn!("主循环运行中");
        delay(1000);
    }
}

调试工具链：

defmt日志框架
probe-run调试器
内存跟踪
性能分析

内存管理

use alloc::{vec, vec::Vec};
use embedded_alloc::Heap;
 
#[global_allocator]
static HEAP: Heap = Heap::empty();
 
#[entry]
fn main() -> ! {
    // 初始化堆内存
    unsafe {
        let heap_start = cortex_m_rt::heap_start() as usize;
        let heap_size = 1024; // 1KB堆空间
        HEAP.init(heap_start, heap_size);
    }
    
    // 使用动态内存
    let mut data = Vec::new();
    data.push(42);
    
    loop {}
}

内存管理策略：

静态内存分配
最小化堆使用
内存池
栈内存优化

最佳实践

资源管理

#[entry]
fn main() -> ! {
    // 使用const泛型优化内存
    const BUFFER_SIZE: usize = 64;
    let mut buffer = [0u8; BUFFER_SIZE];
    
    // 使用静态分配
    static mut DATA: [u8; 1024] = [0; 1024];
    
    loop {}
}

错误处理

use nb::block;
 
fn read_sensor() -> nb::Result<u16, Error> {
    match sensor.read() {
        Ok(data) => Ok(data),
        Err(nb::Error::WouldBlock) => Err(nb::Error::WouldBlock),
        Err(nb::Error::Other(e)) => Err(nb::Error::Other(e)),
    }
}

电源管理

use cortex_m::asm;
 
fn sleep_mode() {
    // 进入低功耗模式
    asm::wfi();
}

总结

Rust在嵌入式开发中提供了：

零成本的抽象能力
强大的类型系统
丰富的硬件抽象层
完善的工具链支持

这些特性使Rust成为嵌入式开发的理想选择，特别是在需要高可靠性和安全性的场景中。

Rust嵌入式开发：no_std环境与硬件访问

引言