Get in Touch

Course Outline

Getting Started with Embedded Rust

  • Overview of the no_std, core, and embedded Rust ecosystem.
  • Selecting a target and understanding target triples.
  • Setting up rustup, cargo, and target toolchains.

Tooling, Build & Debug Workflow

  • Utilizing workflows for cargo, cargo-embed, probe-run, and OpenOCD.
  • Flashing and debugging using hardware probes (ST-Link, JLink).
  • CI considerations for building embedded Rust firmware.

Hardware Abstraction and Peripheral Access

  • Understanding embedded-hal traits and driver patterns.
  • Peripheral access crates (PACs) and device crates (svd2rust).
  • Writing and using HAL drivers and board support crates (BSCs).

Memory Safety, Concurrency & Real-Time

  • Safe patterns for shared state and mutable references in interrupts.
  • RTIC and other concurrency models suitable for real-time systems.
  • Heap versus stack usage, allocators, and strategies for avoiding dynamic allocation.

Error Handling, Testing & Reliability

  • Error handling patterns in constrained environments.
  • Unit testing on the host versus integration testing on hardware.
  • Fault analysis, logging, and post-mortem strategies.

Performance, Power & Resource Optimization

  • Benchmarking, measurement, and optimizing hot paths.
  • Techniques for reducing code size and managing linker scripts.
  • Power management strategies and low-power design patterns.

Deployment, Security & Ecosystem Best Practices

  • Secure boot, firmware signing, and update strategies.
  • Supply-chain considerations and dependency management.
  • Roadmap for migrating C firmware to Rust and community resources.

Summary and Next Steps

Requirements

  • A solid grasp of core Rust concepts: ownership, borrowing, and lifetimes.
  • Practical experience writing non-trivial Rust programs (intermediate proficiency).
  • Familiarity with embedded systems concepts: memory-mapped I/O, interrupts, and peripherals.

Audience

  • Embedded firmware engineers looking to adopt Rust.
  • Software engineers with Rust experience transitioning to low-level systems.
  • Technical leads evaluating Rust for embedded product development.
 14 Hours

Number of participants


Price per participant

Testimonials (2)

Upcoming Courses

Related Categories