my_stm32_project/
├── Core/
│   ├── Src/
│   │   ├── main.c              ← 应用入口
│   │   ├── stm32f4xx_it.c      ← 中断服务函数
│   │   └── system_stm32f4xx.c  ← 系统初始化（时钟等）
│   └── Inc/
│       ├── main.h
│       └── stm32f4xx_it.h
├── Drivers/
│   ├── CMSIS/                   ← ARM 官方核心支持包
│   └── STM32F4xx_HAL_Driver/    ← ST 官方 HAL 库
├── startup_stm32f407xx.s        ← 启动汇编（向量表 + Reset_Handler）
├── STM32F407VGTX_FLASH.ld       ← 链接脚本
├── Makefile / .cproject         ← 构建系统
└── .mxproject                   ← CubeMX 工程文件

[package]
name = "my_first_bare_metal"
version = "0.1.0"
edition = "2021"

[dependencies]
# Cortex-M 运行时：提供向量表、启动代码、入口点宏
cortex-m-rt = "0.7"

# Cortex-M 核心外设访问（NVIC、SCB、SysTick 等）
cortex-m = "0.7"

# Panic 处理：程序崩溃时的行为（这里选择死循环）
panic-halt = "1.0"

# 日志框架（可选，但强烈推荐）
defmt = "0.3"
defmt-rtt = "0.4"

[profile.release]
# 优化配置（详见第 14 章）
opt-level = "s"       # 优化体积
lto = true            # 链接时优化
codegen-units = 1     # 单编译单元（更好的优化）
panic = "abort"       # 不生成 unwind 代码（嵌入式不需要）

# .cargo/config.toml

# 1. 默认编译目标
[build]
target = "thumbv7em-none-eabihf"

# 2. 运行器：cargo run 时用什么工具烧录和运行
[target.thumbv7em-none-eabihf]
runner = "probe-rs run --chip STM32F407VGTx"

# 3. 链接器参数
rustflags = [
    # 使用 memory.x 作为链接脚本的补充
    "-C", "link-arg=-Tlink.x",
    # 启用 defmt 日志（可选）
    "-C", "link-arg=-Tdefmt.x",
]

# 4. 环境变量（defmt 日志格式）
[env]
DEFMT_LOG = "debug"

// build.rs
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::PathBuf;

fn main() {
    // 告诉 Cargo：如果 memory.x 变了，重新执行 build.rs
    println!("cargo:rerun-if-changed=memory.x");

    // 将 memory.x 复制到 OUT_DIR，让链接器能找到它
    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
    File::create(out.join("memory.x"))
        .unwrap()
        .write_all(include_bytes!("memory.x"))
        .unwrap();

    // 将 OUT_DIR 加入链接器搜索路径
    println!("cargo:rustc-link-search={}", out.display());

    // 告诉 rustc 使用 link.x 链接脚本
    println!("cargo:rustc-link-arg=-Tlink.x");
}

; C 的 startup_stm32f407xx.s（简化）
Reset_Handler:
    ; 1. 设置栈指针（由链接脚本提供 _estack）
    LDR SP, =_estack

    ; 2. 复制 .data 段（从 Flash 到 RAM）
    LDR R0, =_sdata        ; RAM 中的起始地址
    LDR R1, =_edata        ; RAM 中的结束地址
    LDR R2, =_sidata       ; Flash 中的源地址
copy_data:
    CMP R0, R1
    BGE zero_bss
    LDR R3, [R2], #4
    STR R3, [R0], #4
    B copy_data

    ; 3. 清零 .bss 段
zero_bss:
    LDR R0, =_sbss
    LDR R1, =_ebss
    MOV R2, #0
zero_loop:
    CMP R0, R1
    BGE call_main
    STR R2, [R0], #4
    B zero_loop

    ; 4. 调用 main
call_main:
    BL main

    ; 5. main 返回后死循环
hang:
    B hang

// src/main.rs
#![no_std]   // 不链接标准库
#![no_main]  // 不使用默认的 main 入口

use cortex_m_rt::entry;
use panic_halt as _;  // panic 时死循环

#[entry]
fn main() -> ! {
    // 你的应用代码从这里开始
    // 此时 .data 已初始化，.bss 已清零，栈已设置好

    loop {
        // 主循环
    }
}

// Rust：中断服务函数
use cortex_m_rt::exception;
use stm32f4xx_hal::pac::interrupt;

// 系统异常（SysTick、HardFault 等）
#[exception]
fn SysTick() {
    // SysTick 中断处理
}

// 外设中断（名称必须与 PAC 中定义的一致）
#[interrupt]
fn USART2() {
    // USART2 中断处理
    // 注意：这里需要通过 unsafe 访问外设寄存器
    // （因为中断可能和主循环并发访问同一外设）
}

# 方法 1：通过 cargo 安装（推荐）
cargo install probe-rs-tools --locked

# 方法 2：通过系统包管理器
# macOS
brew install probe-rs
# Ubuntu/Debian
sudo apt install probe-rs
# Windows (scoop)
scoop install probe-rs

# 验证安装
probe-rs --version
# probe-rs 0.27.0 (2026-xx-xx)

# 验证探针连接
probe-rs list
# 输出示例：
# The following debug probes were found:
# [0]: STLink V2 (VID: 0483, PID: 3748, Serial: 066DFF555051897267013127)

┌─────────────────────────────────────────────────────────┐
│                      芯片 RAM                            │
│                                                         │
│  ┌─────────────────────────────────────────────────┐    │
│  │           RTT 控制块（Control Block）              │    │
│  │                                                 │    │
│  │  ┌──────────────┐    ┌──────────────┐          │    │
│  │  │ Up Buffer 0  │    │ Down Buffer 0│          │    │
│  │  │ (芯片→主机)   │    │ (主机→芯片)   │          │    │
│  │  │ 1024 bytes   │    │ 16 bytes     │          │    │
│  │  └──────────────┘    └──────────────┘          │    │
│  └─────────────────────────────────────────────────┘    │
│                                                         │
│  你的应用代码：                                          │
│  defmt::info!("Counter: {}", count);                    │
│       │                                                 │
│       ▼                                                 │
│  将格式化数据写入 Up Buffer                              │
└─────────────────────────────────────────────────────────┘
         │
         │ SWD 调试接口（2 根线：SWDIO + SWCLK）
         │
┌────────┴────────┐
│   probe-rs      │
│   (主机端)      │
│                 │
│  轮询 Up Buffer │
│  读取新数据     │
│  输出到终端     │
└─────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                        开发阶段                                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  src/main.rs ──→ rustc ──→ LLVM IR ──→ LLVM ──→ .o 文件        │
│  (你的代码)     (Rust     (中间        (优化 +   (目标           │
│                  前端)     表示)        代码生成)  机器码)         │
│                                                                 │
│  依赖 crates ──→ 同样经过 rustc + LLVM 编译为 .rlib             │
│                                                                 │
│  .o + .rlib ──→ rust-lld ──→ ELF 文件                           │
│  (所有目标文件)  (链接器)     (可执行文件，                       │
│                              包含调试信息)                       │
│                                                                 │
│  memory.x ──→ 链接脚本（定义 Flash/RAM 地址）                    │
│  link.x ────→ cortex-m-rt 提供的链接脚本模板                    │
│                                                                 │
├─────────────────────────────────────────────────────────────────┤
│                        烧录阶段                                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ELF 文件 ──→ probe-rs ──→ SWD/JTAG ──→ 芯片 Flash             │
│               (解析 ELF,   (调试        (物理                    │
│                提取二进制,  接口)         写入)                   │
│                调用 Flash                                       │
│                算法)                                            │
│                                                                 │
├─────────────────────────────────────────────────────────────────┤
│                        运行阶段                                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  芯片上电 ──→ 读取向量表 ──→ Reset_Handler ──→ 初始化            │
│              (0x08000000)   (cortex-m-rt)    (.data/.bss)       │
│                                                     │           │
│                                                     ▼           │
│                                              你的 main()        │
│                                                     │           │
│                                                     ▼           │
│                                              主循环 / 任务       │
│                                                     │           │
│                                              RTT 日志输出        │
│                                              (写入 RAM 缓冲区)   │
│                                                     │           │
│                                              probe-rs 读取       │
│                                              (通过 SWD)          │
│                                                     │           │
│                                              终端显示            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

[package]
name = "hello_bare_metal"
version = "0.1.0"
edition = "2021"

[dependencies]
cortex-m-rt = "0.7"
cortex-m = "0.7"
panic-halt = "1.0"
defmt = "0.3"
defmt-rtt = "0.4"

[profile.release]
opt-level = "s"
lto = true
codegen-units = 1
panic = "abort"

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use defmt_rtt as _;
use panic_halt as _;

#[entry]
fn main() -> ! {
    defmt::info!("Hello from bare-metal Rust!");

    let mut counter: u32 = 0;

    loop {
        defmt::info!("Counter: {}", counter);
        counter += 1;

        // 简单的忙等待延时（后续章节会用 Timer 替代）
        cortex_m::asm::delay(8_000_000);
    }
}