Rust 嵌入式开发与 FFI 互操作：no_std、embedded-hal 与 C 接口

#![no_std]           // 不用标准库
#![no_main]          // 无 main（嵌入式入口由硬件启动代码决定）

[package]
name = "my-firmware"
version = "0.1.0"

[profile.release]
debug = 1
opt-level = "s"
overflow-checks = true

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

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use panic_halt as _;   // panic 时停机

#[entry]
fn main() -> ! {
    // 无限主循环
    loop {
        // 业务逻辑
    }
}

use embedded_hal::digital::OutputPin;
use embedded_hal::spi::SpiBus;
use embedded_hal::i2c::I2c;

// 任何实现了 OutputPin 的芯片都能跑这段代码
fn blink<LED>(mut led: LED) where LED: OutputPin {
    led.set_high().ok();
    // 延时
    led.set_low().ok();
}

// 通用 I2C 读取温度传感器
fn read_temp<I>(i2c: &mut I) -> Result<u16, ()>
where I: I2c {
    let mut buf = [0u8; 2];
    i2c.write_read(0x48, &[0x00], &mut buf).map_err(|_| ())?;
    Ok(u16::from_be_bytes([buf[0], buf[1]]))
}

#![no_std]
#![no_main]

use esp_backtrace as _;
use esp_hal::{clock::ClockControl, peripherals::Peripherals, prelude::*, timer::TimerGroup};
use esp_wifi::{initialize, wifi::WifiAp};

#[entry]
fn main() -> ! {
    let peripherals = Peripherals::take();
    let system = peripherals.SYSTEM;
    let clocks = ClockControl::boot_defaults().freeze();

    // GPIO2 配置为输出
    let mut led = esp_hal::gpio::IO::new(peripherals.GPIO, peripherals.IO_MUX)
        .pins
        .gpio2
        .into_push_pull_output();

    loop {
        led.toggle();
        esp_hal::time::delay(500u32.millis());
    }
}

use stm32f4xx_hal::{pac, prelude::*, serial::Serial};

fn main() {
    let dp = pac::Peripherals::take().unwrap();
    let rcc = dp.RCC.constrain();
    let clocks = rcc.cfgr.freeze();
    let mut gpioa = dp.GPIOA.split();
    let tx = gpioa.pa2.into_alternate();
    let rx = gpioa.pa3.into_alternate();
    let serial = Serial::new(dp.USART2, (tx, rx), 115200.bps(), clocks);
    let (mut tx, _rx) = serial.split();
    loop {
        tx.write_str("hello from STM32\r\n").ok();
        delay();
    }
}

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    loop {
        // 异步定时任务，不阻塞
        Timer::after(Duration::from_millis(1000)).await;
        // 周期执行逻辑
    }
}

// 多个并发任务
#[embassy_executor::task]
async fn blink_task() {
    loop {
        // LED 闪烁
        Timer::after(Duration::from_millis(500)).await;
    }
}

// 调用 C 库函数
extern "C" {
    fn strlen(s: *const u8) -> usize;
    fn malloc(size: usize) -> *mut u8;
}

fn c_len(s: &str) -> usize {
    unsafe { strlen(s.as_ptr()) }
}

#[repr(C)]           // 保证字段布局与 C 一致
struct CPoint {
    x: f64,
    y: f64,
}

#[repr(C, u8)]       // 带 tag 的枚举（类似 C union + tag）
enum CEvent {
    Mouse(u32, u32),
    Key(u8),
}

// lib.rs
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 导出内存操作（供 C 分配/释放）
#[no_mangle]
pub extern "C" fn my_alloc(size: usize) -> *mut u8 {
    let mut v = Vec::with_capacity(size);
    let ptr = v.as_mut_ptr();
    std::mem::forget(v);   // 交给 C 管理
    ptr
}

#[no_mangle]
pub extern "C" fn my_free(ptr: *mut u8) {
    unsafe {
        let v = Vec::from_raw_parts(ptr, 0, 0);  // 简化示例
        drop(v);
    }
}

// main.c
#include <stdio.h>
extern int add(int, int);

int main() {
    printf("%d\n", add(2, 3));
    return 0;
}

# 编译链接
rustc --crate-type=cdylib src/lib.rs -o librustlib.so
gcc main.c -L. -lrustlib -o app

# 安装
cargo install bindgen-cli

# 生成绑定
bindgen include/my_lib.h -o src/bindings.rs \
  --allowlist-function "my_.*" \
  --allowlist-type "MyStruct"

// my_lib.h
typedef struct {
    int width;
    int height;
} MyRect;

int my_area(const MyRect *rect);
void my_fill(MyRect *rect, int w, int h);

// 生成的 bindings.rs
#[repr(C)]
pub struct MyRect {
    pub width: ::std::os::raw::c_int,
    pub height: ::std::os::raw::c_int,
}
extern "C" {
    pub fn my_area(rect: *const MyRect) -> ::std::os::raw::c_int;
    pub fn my_fill(rect: *mut MyRect, w: ::std::os::raw::c_int, h: ::std::os::raw::c_int);
}

mod cbindings;   // 生成的绑定

pub struct Rect { width: i32, height: i32 }

impl Rect {
    pub fn new(w: i32, h: i32) -> Self { Self { width: w, height: h } }
    pub fn area(&self) -> i32 {
        let r = cbindings::MyRect { width: self.width, height: self.height };
        unsafe { cbindings::my_area(&r) }
    }
}

// 安全封装示例：确保指针生命周期
pub struct CStringGuard(*mut c_char);

impl CStringGuard {
    pub fn from_raw(ptr: *mut c_char) -> Option<Self> {
        (!ptr.is_null()).then(|| Self(ptr))
    }
    pub fn as_str(&self) -> &str {
        unsafe { std::ffi::CStr::from_ptr(self.0) }
            .to_str()
            .unwrap_or("")
    }
}

impl Drop for CStringGuard {
    fn drop(&mut self) {
        unsafe { free(self.0) }   // 配套 C 的 free
    }
}