内存、堆栈与 alloc

关键概念

RAM 布局：栈、静态与（可选）堆

理解 RAM 里各区域如何排布，就理解了栈溢出的危害与 flip-link 的价值：

heapless：不用堆的动态集合

大多数"看起来需要 Vec"的场景，其实容量有上界。heapless 让你用熟悉的 API、却把数据放在固定大小的内联存储里：

use heapless::{Vec, String};

// 容量 8 的 Vec，数据内联在结构体里（无堆分配）
let mut samples: Vec<u16, 8> = Vec::new();
samples.push(100).unwrap();   // 满了返回 Err(value)，不会自动扩容
samples.push(200).unwrap();

// 计算平均值，和 std 的迭代器 API 完全一样
let avg: u32 = samples.iter().map(|&x| x as u32).sum::<u32>()
    / samples.len() as u32;

// 容量 32 字节的定长字符串，用 write! 格式化，无需堆
use core::fmt::Write;
let mut msg: String<32> = String::new();
write!(msg, "avg={}", avg).unwrap();

SPSC 队列：ISR 到 main 的无锁传输

use heapless::spsc::{Queue, Producer, Consumer};

// 静态队列：容量 16，跨 ISR/main 共享
static mut Q: Queue<u8, 16> = Queue::new();

// 在 init 中 split 成生产者/消费者两半（此处示意）
// let (mut producer, mut consumer) = unsafe { Q.split() };

// —— ISR 侧：生产者，串口收到字节就入队 ——
// producer.enqueue(byte).ok();   // 满则丢弃，无需临界区

// —— main 侧：消费者，取出处理 ——
// while let Some(b) = consumer.dequeue() { process(b); }

// SPSC 用原子读写索引，单生产者单消费者天然无数据竞争

确实需要堆时：接入全局分配器

解析变长协议、用某个只支持 alloc 的库时，可以开一小块堆。代价是引入不确定性，应谨慎：

#![no_std]
#![no_main]
extern crate alloc;                         // 启用 alloc 库
use alloc::vec::Vec;                          // 这才是会分配堆的 Vec
use embedded_alloc::LlffHeap as Heap;

// 注册全局分配器
#[global_allocator]
static HEAP: Heap = Heap::empty();

#[cortex_m_rt::entry]
fn main() -> ! {
    // 给分配器一块 8KB 的静态 RAM 作为堆区
    {
        use core::mem::MaybeUninit;
        const HEAP_SIZE: usize = 8192;
        static mut MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
        unsafe { HEAP.init(&raw mut MEM as usize, HEAP_SIZE) }
    }

    // 现在可以用 Box / Vec / String（alloc 版）了
    let mut v: Vec<u32> = Vec::new();
    v.push(42);                                 // 动态扩容，从堆分配

    loop {}
}

选型决策