《深入Rust系统编程》8.2 设备驱动开发

January 18, 2025

Rust 系统编程：8.2 设备驱动开发

设备驱动是操作系统与硬件设备之间的桥梁，负责管理硬件设备的操作和数据传输。Rust 作为一种内存安全的系统编程语言，非常适合用于开发设备驱动。本文将深入探讨 Rust 中的设备驱动开发，涵盖设备驱动的基本概念、开发步骤、硬件抽象层（HAL）、以及实际示例。

8.2.1 设备驱动开发概述

8.2.1.1 什么是设备驱动？

设备驱动是一种软件组件，用于控制和管理硬件设备。它提供了与硬件设备交互的接口，使操作系统和应用程序能够访问和使用硬件设备的功能。

8.2.1.2 设备驱动的分类

设备驱动可以分为以下几类：

字符设备驱动：用于管理字符设备（如键盘、鼠标）。
块设备驱动：用于管理块设备（如硬盘、SSD）。
网络设备驱动：用于管理网络设备（如网卡）。
总线设备驱动：用于管理总线设备（如 PCI、USB）。

8.2.1.3 Rust 在设备驱动开发中的优势

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

8.2.2 设备驱动开发步骤

8.2.2.1 选择目标硬件

设备驱动开发的第一步是选择目标硬件。常见的硬件设备包括：

GPIO：通用输入输出引脚。
I2C：用于连接低速外设的串行总线。
SPI：用于连接高速外设的串行总线。
UART：用于串行通信的通用异步收发器。

本文将以 STM32F3DISCOVERY 开发板为例。

8.2.2.2 配置开发环境

8.2.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.2.2.2.2 安装调试工具

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

1

sudo apt install openocd

8.2.2.3 创建设备驱动项目

使用 cargo 创建一个新的设备驱动项目：

1
2


cargo new --bin stm32f3-driver
cd stm32f3-driver

在 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.2.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.2.2.5 编译和烧录程序

8.2.2.5.1 编译程序

使用 cargo 编译程序：

1

cargo build --release

8.2.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-driver

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

1
2
3
4


target remote :3333
load
monitor reset halt
continue

8.2.2.6 调试程序

使用 GDB 进行调试：

设置断点：
1

break main
运行程序：
1

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

print led info registers

8.2.3 硬件抽象层（HAL）

8.2.3.1 什么是 HAL？

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

8.2.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.2.4 实际应用示例

8.2.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.2.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.2.5 总结

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