1. 前言
在上一篇报告中,我们成功在瑞萨 RA4M2 上跑通了 Rust 混合开发环境,并打印出了标志着成功的小螃蟹。但这仅仅是“地基”。嵌入式开发真正的乐趣在于驱动各种传感器。
本篇报告我们将挑战 ST VL53L0X 激光测距传感器。

VL53L0X 是一款基于飞行时间(ToF)技术的激光测距模块,能在极小封装内提供高达 2 米的精确距离测量。在 C 语言的视角下,这类驱动通常意味着要对着几百页的寄存器手册编写复杂的初始化序列;

但在 Rust 生态中,得益于 embedded-hal的存在,只需要实现基础的 I2C 读写,剩下的“脏活累活”都可以交给社区现成的驱动包。
2. 实现细节
2.1 引入依赖
在 Cargo.toml 中,除了引入必要的运行时库,还需要添加 vl53l0x 驱动库和 embedded-hal 接口:
[dependencies]
cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
cortex-m-rt = "0.7"
panic-halt = "0.2"
rtt-target = "0.5"
panic-probe = { version = "0.3", features = ["print-rtt"] }
# hal drivers
embedded-hal = { version = "0.2.7", features = ["unproven"] }
vl53l0x = "0.2.2"
2.2 实现 embedded-hal
Rust 驱动库不直接操作硬件,而是通过 embedded-hal 定义的hal抽象层进行交互。为了驱动VL53L0X I2C,需要为 RA4M2 编写两个基础组件:RaPin实现引脚控制和 RaDelay提供精准延时。
通过封装 FSP 的底层 API,让 Rust 能够操作 RA4M2 的引脚:
pub struct RaPin(pub u16);
impl OutputPin for RaPin {
type Error = Infallible;
fn set_low(&mut self) -> Result<(), Self::Error> {
unsafe { R_IOPORT_PinWrite(&raw mut g_ioport_ctrl as *mut _ as *mut _, self.0, 0); }
Ok(())
}
fn set_high(&mut self) -> Result<(), Self::Error> {
unsafe { R_IOPORT_PinWrite(&raw mut g_ioport_ctrl as *mut _ as *mut _, self.0, 1); }
Ok(())
}
}
impl InputPin for RaPin {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Self::Error> {
let mut level = 0u8;
unsafe { R_IOPORT_PinRead(&raw mut g_ioport_ctrl as *mut _ as *mut _, self.0, &mut level); }
Ok(level == 1)
}
fn is_low(&self) -> Result<bool, Self::Error> { Ok(!self.is_high()?) }
}
使用nop实现一个简单的延时
pub struct RaDelay;
impl DelayUs<u32> for RaDelay {
fn delay_us(&mut self, us: u32) {
for _ in 0..(us * 15) { cortex_m::asm::nop(); }
}
}
impl DelayMs<u32> for RaDelay {
fn delay_ms(&mut self, ms: u32) {
for _ in 0..ms { self.delay_us(1000); }
}
}
2.3 软件模拟 I2C
为了展示灵活性,借助前一节实现的引脚操作以及Delay,本节实现了一个基于 GPIO 模拟的 SoftI2c。它完全遵循 embedded-hal 的 Write、Read 和 WriteRead 接口。这样一来,无论底层引脚如何变化,上层的 VL53L0X 驱动都无需修改代码。
这种“软件定义外设”的方式,在 RA4M2 这种引脚功能极其灵活的芯片上非常实用,尤其是在硬件 I2C 资源紧张或引脚冲突的情况下。
use core::convert::Infallible;
use embedded_hal::blocking::delay::DelayUs;
use embedded_hal::blocking::i2c::{Read, Write, WriteRead};
use embedded_hal::digital::v2::{InputPin, OutputPin};
pub struct SoftI2c<SCL, SDA, DELAY> {
scl: SCL,
sda: SDA,
delay: DELAY,
}
impl<SCL, SDA, DELAY> SoftI2c<SCL, SDA, DELAY>
where
SCL: OutputPin,
SDA: OutputPin + InputPin,
DELAY: DelayUs<u32>,
{
pub fn new(scl: SCL, sda: SDA, delay: DELAY) -> Self {
let mut i2c = Self { scl, sda, delay };
let _ = i2c.scl.set_high();
let _ = i2c.sda.set_high();
i2c
}
fn i2c_start(&mut self) {
let _ = self.sda.set_high();
let _ = self.scl.set_high();
self.delay.delay_us(5);
let _ = self.sda.set_low();
self.delay.delay_us(5);
let _ = self.scl.set_low();
}
fn i2c_stop(&mut self) {
let _ = self.sda.set_low();
let _ = self.scl.set_high();
self.delay.delay_us(5);
let _ = self.sda.set_high();
self.delay.delay_us(5);
}
fn i2c_write_byte(&mut self, byte: u8) -> bool {
for i in 0..8 {
if (byte & (0x80 >> i)) != 0 { let _ = self.sda.set_high(); }
else { let _ = self.sda.set_low(); }
self.delay.delay_us(5);
let _ = self.scl.set_high();
self.delay.delay_us(5);
let _ = self.scl.set_low();
}
let _ = self.sda.set_high();
self.delay.delay_us(5);
let _ = self.scl.set_high();
let ack = self.sda.is_low().unwrap_or(false);
self.delay.delay_us(5);
let _ = self.scl.set_low();
ack
}
fn i2c_read_byte(&mut self, ack: bool) -> u8 {
let mut byte = 0u8;
let _ = self.sda.set_high();
for i in 0..8 {
self.delay.delay_us(5);
let _ = self.scl.set_high();
if self.sda.is_high().unwrap_or(false) { byte |= 0x80 >> i; }
self.delay.delay_us(5);
let _ = self.scl.set_low();
}
if ack { let _ = self.sda.set_low(); } else { let _ = self.sda.set_high(); }
let _ = self.scl.set_high();
self.delay.delay_us(5);
let _ = self.scl.set_low();
let _ = self.sda.set_high();
byte
}
}
impl<SCL, SDA, DELAY> Write for SoftI2c<SCL, SDA, DELAY>
where SCL: OutputPin, SDA: OutputPin + InputPin, DELAY: DelayUs<u32>,
{
type Error = Infallible;
fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
self.i2c_start();
self.i2c_write_byte(addr << 1);
for b in bytes { self.i2c_write_byte(*b); }
self.i2c_stop();
Ok(())
}
}
impl<SCL, SDA, DELAY> WriteRead for SoftI2c<SCL, SDA, DELAY>
where SCL: OutputPin, SDA: OutputPin + InputPin, DELAY: DelayUs<u32>,
{
type Error = Infallible;
fn write_read(&mut self, addr: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Self::Error> {
self.write(addr, bytes)?;
self.i2c_start();
self.i2c_write_byte((addr << 1) | 1);
let len = buffer.len();
for i in 0..len { buffer[i] = self.i2c_read_byte(i < len - 1); }
self.i2c_stop();
Ok(())
}
}
impl<SCL, SDA, DELAY> Read for SoftI2c<SCL, SDA, DELAY>
where SCL: OutputPin, SDA: OutputPin + InputPin, DELAY: DelayUs<u32>,
{
type Error = Infallible;
fn read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
self.i2c_start();
self.i2c_write_byte((addr << 1) | 1);
let len = buffer.len();
for i in 0..len { buffer[i] = self.i2c_read_byte(i < len - 1); }
self.i2c_stop();
Ok(())
}
}
- FSP配置
由于我们使用gpio模拟I2C, 我们复用[上一篇文章]([RA4M2-SENSOR] Rust-FSP混合编程-瑞萨电子-芯查查)中的时钟配置,仅配置I2C模拟IO,以及中断,Xshut引脚



注意:SDA, SCL输出类型的配置为
n-ch open drain
2.4 应用
现在, hal_entry 中的逻辑变得异常清晰。我们不再需要处理复杂的寄存器魔数,而是以一种“声明式”的风格初始化传感器:
- 硬件复位:通过
xshut引脚唤醒传感器。 - 对象实例化:将
SoftI2c注入vl53l0x驱动。 - 配置与启动:设置 33ms 的测量时间并开启连续测量模式。
#[unsafe(no_mangle)]
pub extern "C" fn hal_entry() {
rtt_init_print!();
rprintln!("--- RA4M2 VL53L0X 启动 ---");
// 硬件初始化
unsafe {
R_IOPORT_Open(&raw mut g_ioport_ctrl as *mut _ as *mut _, &g_bsp_pin_cfg);
R_SCI_UART_Open(&raw mut g_uart9_ctrl as *mut _ as *mut _, &g_uart9_cfg);
// cortex_m::interrupt::enable();
}
let mut delay = RaDelay;
// 引脚
let scl = RaPin(e_bsp_io_port_pin_t_BSP_IO_PORT_03_PIN_01 as u16);
let sda = RaPin(e_bsp_io_port_pin_t_BSP_IO_PORT_03_PIN_02 as u16);
let mut xshut = RaPin(e_bsp_io_port_pin_t_BSP_IO_PORT_00_PIN_01 as u16);
// 传感器唤醒
let _ = xshut.set_low();
delay.delay_ms(10);
let _ = xshut.set_high();
delay.delay_ms(10);
// I2C总线
let i2c = SoftI2c::new(scl, sda, RaDelay);
// 驱动
let mut tof = match vl53l0x::VL53L0x::new(i2c) {
Ok(s) => s,
Err(_) => {
rprintln!("错误: I2C 初始化失败");
loop {}
}
};
let _ = tof.set_measurement_timing_budget(33000);
let _ = tof.start_continuous(0);
rprintln!("系统就绪,开始转发数据...");
loop {
match tof.read_range_continuous_millimeters_blocking() {
Ok(dist) => {
if dist < 8190 {
rprintln!("距离: {} mm", dist);
}
else { rprintln!("超出范围"); }
}
Err(_) => rprintln!("读取失败"),
}
delay.delay_ms(100);
}
}
3. 效果
按下 F5 编译并烧录,probe-rs 瞬间完成部署。当手掌在传感器前晃动时,RTT 控制台输出了实时稳定的距离数据:

Finished `release` profile [optimized + debuginfo] target(s) in 0.30s
Running `probe-rs run --chip R7FA4M2AD target\thumbv8m.main-none-eabihf\release\ra4m2-blink`
Erasing ✔ 100% [####################] 16.00 KiB @ 16.36 KiB/s (took 1s)
Programming ✔ 100% [####################] 14.62 KiB @ 1.98 KiB/s (took 7s)
Erasing 2 ✔ 100% [####################] 48 B @ 53 B/s (took 1s)
Programming 2 ✔ 100% [####################] 48 B @ 167 B/s (took 0s) Finished in 9.64s
--- RA4M2 VL53L0X 启动 ---
10:56:51.875: 系统就绪,开始转发数据...
10:56:51.875: 距离: 280 mm
10:56:52.000: 距离: 279 mm
10:56:52.125: 距离: 277 mm
10:56:52.249: 距离: 279 mm
10:56:52.375: 距离: 278 mm
10:56:52.610: 距离: 280 mm
10:56:52.735: 距离: 279 mm
10:56:52.859: 距离: 277 mm
10:56:52.984: 距离: 275 mm
10:56:53.109: 距离: 282 mm
4. 总结
通过这次适配,我们深刻体会到了 “Rust 生态赋能硬件” 的威力。
如果使用 C 语言,即使有现成的参考代码,开发者往往也需要耗费大量时间处理:
- 结构体字节对齐问题。
- I2C 读写序列的逻辑漏洞。
- 繁琐的各种标定寄存器操作。
而在 RA4M2 + Rust 的环境下,我们通过实现 embedded-hal,成功在 100 行代码以内驱动了这款高性能传感器。FSP 负责底层初始化,Rust 负责高层逻辑,两者相得益彰。
现在的 RA4M2 已经具备了感知空间距离的能力。在下一篇报告中,我们将尝试将这些实时数据,通过 USB 转串口,传输给上位机系统!

全部评论