《深入Rust系统编程》8.1 嵌入式系统开发

January 18, 2025

Rust 系统编程：8.1 嵌入式系统开发

嵌入式系统开发是 Rust 的一个重要应用领域。Rust 的内存安全性和高性能使其成为嵌入式开发的理想选择。嵌入式系统通常运行在资源受限的环境中，如微控制器（MCU），因此需要高效、可靠的编程语言和工具链。本文将深入探讨 Rust 在嵌入式系统开发中的应用，涵盖开发步骤、工具链配置、硬件抽象层（HAL）、以及实际示例。

8.1.1 嵌入式系统开发概述

8.1.1.1 什么是嵌入式系统？

嵌入式系统是专为特定任务设计的计算机系统，通常嵌入在更大的设备中。它们广泛应用于家电、汽车、医疗设备、工业控制系统等领域。嵌入式系统的特点包括：

资源受限：有限的内存、存储和计算能力。
实时性：需要在严格的时间限制内完成任务。
低功耗：通常由电池供电，需要优化功耗。

8.1.1.2 Rust 在嵌入式开发中的优势

内存安全：Rust 的所有权系统避免了常见的内存错误（如空指针、缓冲区溢出）。
高性能：Rust 生成的代码性能接近 C/C++。
丰富的生态系统：Rust 提供了许多嵌入式开发工具和库。

8.1.2 嵌入式开发步骤

8.1.2.1 选择目标硬件

嵌入式开发的第一步是选择目标硬件。常见的嵌入式开发板包括：

STM32 系列：如 STM32F3、STM32F4。
Raspberry Pi Pico：基于 RP2040 微控制器。
ESP32：集成了 Wi-Fi 和蓝牙功能。

本文将以 STM32F3DISCOVERY 开发板为例。

8.1.2.2 配置开发环境

8.1.2.2.1 安装 Rust 工具链

首先，安装 Rust 工具链：

1

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

然后，添加嵌入式开发所需的工具链和目标：

1
2
3


rustup target add thumbv7em-none-eabihf
rustup component add llvm-tools-preview
cargo install cargo-binutils

8.1.2.2.2 安装调试工具

安装 OpenOCD（用于调试和烧录）：

1

sudo apt install openocd

8.1.2.3 创建嵌入式项目

使用 cargo 创建一个新的嵌入式项目：

1
2


cargo new --bin stm32f3-discovery
cd stm32f3-discovery

在 Cargo.toml 中添加依赖：

1
2
3
4
5
6
7
8


[dependencies]
cortex-m = "0.7"
cortex-m-rt = "0.7"
panic-halt = "0.2"

[dependencies.stm32f3xx-hal]
version = "0.8"
features = ["stm32f303xc"]

8.1.2.4 编写嵌入式程序

在 src/main.rs 中编写嵌入式程序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#![no_std]
#![no_main]

use panic_halt as _;
use cortex_m_rt::entry;
use stm32f3xx_hal::{prelude::*, stm32};

#[entry]
fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();
    let mut rcc = dp.RCC.constrain();
    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);

    let mut led = gpioe
        .pe9
        .into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper);

    loop {
        led.toggle().unwrap();
        cortex_m::asm::delay(8_000_000); // 延迟约 1 秒
    }
}

代码说明

#![no_std]：禁用标准库，使用核心库（core）。
#![no_main]：禁用标准 main 函数，使用 #[entry] 宏定义入口点。
panic_halt：定义 panic 处理程序。
stm32f3xx_hal：STM32F3 系列的硬件抽象层（HAL）。
gpioe.pe9：配置 PE9 引脚为推挽输出，用于控制 LED。

8.1.2.5 编译和烧录程序

8.1.2.5.1 编译程序

使用 cargo 编译程序：

1

cargo build --release

8.1.2.5.2 烧录程序

使用 OpenOCD 和 GDB 烧录程序：

启动 OpenOCD：

1

openocd -f interface/stlink-v2-1.cfg -f target/stm32f3x.cfg

在另一个终端中启动 GDB：

1

arm-none-eabi-gdb -q target/thumbv7em-none-eabihf/release/stm32f3-discovery

在 GDB 中连接 OpenOCD 并烧录程序：

1
2
3
4


target remote :3333
load
monitor reset halt
continue

8.1.2.6 调试程序

使用 GDB 进行调试：

设置断点：
1

break main
运行程序：
1

continue
查看变量和寄存器：
1 2

print led info registers

8.1.3 硬件抽象层（HAL）

8.1.3.1 什么是 HAL？

硬件抽象层（Hardware Abstraction Layer, HAL）是一组抽象接口，用于屏蔽底层硬件的细节，提供统一的 API 给上层应用程序。Rust 的 HAL 通常基于 embedded-hal trait，定义了通用的硬件接口（如 GPIO、I2C、SPI 等）。

8.1.3.2 使用 `stm32f3xx-hal`

stm32f3xx-hal 是 STM32F3 系列的硬件抽象层库。它提供了对 GPIO、定时器、串口等外设的抽象。

以下是一个使用 stm32f3xx-hal 控制 LED 的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


use stm32f3xx_hal::{prelude::*, stm32};

fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();
    let mut rcc = dp.RCC.constrain();
    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);

    let mut led = gpioe
        .pe9
        .into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper);

    loop {
        led.toggle().unwrap();
        cortex_m::asm::delay(8_000_000); // 延迟约 1 秒
    }
}

8.1.4 实际应用示例

8.1.4.1 控制多个 LED

以下是一个控制多个 LED 的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


use stm32f3xx_hal::{prelude::*, stm32};

fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();
    let mut rcc = dp.RCC.constrain();
    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);

    let mut leds = [
        gpioe.pe9.into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper),
        gpioe.pe10.into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper),
        gpioe.pe11.into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper),
        gpioe.pe12.into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper),
    ];

    loop {
        for led in leds.iter_mut() {
            led.toggle().unwrap();
            cortex_m::asm::delay(2_000_000); // 延迟约 0.25 秒
        }
    }
}

8.1.4.2 使用定时器

以下是一个使用定时器控制 LED 闪烁的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


use stm32f3xx_hal::{prelude::*, stm32, timer::Timer};

fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();
    let mut rcc = dp.RCC.constrain();
    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);

    let mut led = gpioe
        .pe9
        .into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper);

    let mut timer = Timer::tim2(dp.TIM2, 1.hz(), rcc.apb1);
    loop {
        led.toggle().unwrap();
        timer.start(1.hz());
        timer.wait().unwrap();
    }
}

8.1.5 总结

Rust 为嵌入式系统开发提供了强大的工具和库。本文详细介绍了嵌入式开发的步骤、工具链配置、硬件抽象层（HAL）的使用，以及实际示例。通过 Rust 的内存安全性和高性能，开发者可以构建高效、可靠的嵌入式应用程序。