Embedded Software with Rust (MEAP) (David Cabanis)（Z-Library）

# Embedded Software with Rust (MEAP) — Reading Guide ## 【One-Line Pitch】 A practical, hands-on introduction to building safe, efficient firmware with Rust for resource-constrained microcontrollers, ideal for embedded C/C++ developers and firmware beginners who want to eliminate entire categories of memory-safety bugs without sacrificing low-level hardware control. ## 【Book Arc】 - **Opening (~0%–9%)**: Establishes why Rust matters for embedded development, contrasting desktop Rust (std-based) with embedded Rust (no_std), and walks through the reset-to-main execution sequence, startup crates (cortex-m-rt, riscv-rt), and core language mechanics like ownership, borrowing, and singleton peripherals. - **Early (~9%–25%)**: Covers toolchain setup — installing rustup, configuring targets (thumbv7m-none-eabi), choosing editors (VS Code extensions, Helix, Zed), and building with cargo for embedded targets, including debug vs. release profiles and output artifacts. - **Early (~25%–34%)**: Introduces binary inspection and manipulation with cargo-binutils and GNU binutils (strings, strip, objdump, objcopy), then walks through streamlining bare-metal project setup using templates and the Knurling suite. - **Middle (~34%–47%)**: Focuses on getting firmware onto real hardware — flashing with OpenOCD, vendor-specific tools (st-flash for STM32, esptool.py for ESP32), and configuring projects for specific boards like the Blue Pill (STM32F103C8) with memory.x linker scripts. - **Middle (~47%–53%)**: Explores emulation and simulation strategies — QEMU, Renode, PICSimLab, Wokwi — for development, CI testing, and collaboration when physical hardware is unavailable or scarce, including their limitations around timing accuracy. ## 【Key Takeaways】 - **Embedded Rust uses no_std, not std** (Early): Unlike desktop Rust, embedded firmware runs without an OS, standard library, or heap by default — requiring explicit entry points, panic handlers, and custom linker scripts (memory.x) for memory layout. - **The startup sequence matters** (Early): From reset, the core loads the stack pointer and reset vector, branches to the reset handler, performs minimal initialization (copying .data, zeroing .bss), then calls the entry point — understanding this explains many Rust and toolchain constraints. - **Ownership and borrowing replace OS-level protection** (Early): Peripheral access, construction-time singletons, and type-state APIs keep resource control explicit and safe without relying on an operating system — a fundamental shift from C-style embedded programming. - **Toolchain setup is straightforward but specific** (Early): rustup, cargo, and target triples (like thumbv7m-none-eabi for Cortex-M3) are the foundation; cargo-binutils and GNU binutils remain essential for inspecting and manipulating firmware binaries. - **Flashing tools vary by vendor and use case** (Middle): OpenOCD offers flexibility across platforms, while st-flash (STM32) and esptool.py (ESP32) provide simpler vendor-specific paths — choose based on your hardware and workflow needs. - **Emulation accelerates development but has limits** (Middle): QEMU, Renode, PICSimLab, and Wokwi enable software-level testing, CI integration, and parallel team work, but they don't guarantee cycle-accurate timing — timing-sensitive tests still need real hardware. - **Project templates and the Knurling suite reduce setup friction** (Middle): Tools like probe-rs and flip-link streamline the edit-build-flash cycle, and configuring a generic project for a specific board (e.g., Blue Pill) requires only a memory.x file and target architecture setting. ## 【Reading Tips】 - **Skim Chapter 1's comparisons** if you're already convinced about Rust for embedded — the desktop-vs-embedded Rust table and startup sequence are worth a careful read, but the adoption arguments can be scanned. - **Deep-read the toolchain chapters (2.1–2.5)** if you're new to embedded Rust setup — the exact commands for rustup, cargo build targets, and flashing utilities are practical and immediately applicable. - **Pay special attention to the memory.x configuration** (Middle section) — this is where many beginners stumble; the Blue Pill example (FLASH 64K, RAM 20K) is a clear template for other boards. - **Use the emulation chapter (2.7) as a reference** rather than reading linearly — you'll want to return to it when setting up CI or when hardware is unavailable. - **The book assumes basic Rust tooling knowledge** (rustup, rustc, cargo) and embedded C/C++ background — if you lack either, brush up before diving in. ## 【Coverage Limits】 Excerpts cover roughly the first half of the book (through ~53%), focusing on fundamentals, toolchain, and workflow. Later chapters on peripheral access, interrupts, communication interfaces, and advanced async patterns are not covered in this guide. ##