info@orb-experts.com
An intermediate course for developers with prior Rust experience who want to build reliable firmware on real hardware. Participants learn the embedded Rust ecosystem, work with common peripherals, design safe concurrent tasks, and debug effectively on target.
You will move from desktop Rust to embedded targets, understand memory and timing constraints, use hardware abstraction layers, and structure applications for reliability. You will configure peripherals, handle interrupts safely, and adopt a repeatable workflow for testing and debugging on device.
After this training you will be confident in:
• Navigating the embedded Rust ecosystem including cortex-m, HALs, and board support packages
• Building no_std firmware, understanding memory layout, and configuring panic and logging
• Driving GPIO, timers, UART, I2C, and SPI using safe abstractions
• Structuring concurrency with interrupts and task frameworks such as RTIC or Embassy
• Debugging on target with probe-rs, defmt logs, and useful assertions
• Packaging firmware for handoff with configuration, versioning, and reproducible builds
• Comfortable with Rust fundamentals including ownership, traits, and generics
• Basic knowledge of microcontrollers and digital I/O
• A supported dev board is helpful but not required for following along
*We know each team has their own needs and specifications. That is why we can modify the training outline per need.
Module 1: Embedded Rust ecosystem and project setup
• Target selection, toolchains, and cross-compilation
• no_std, alloc, memory layout, and linker basics
• Panic behavior, logging with defmt, and configuration by feature flags
• Board support packages vs vendor HALs and when to use each
Module 2: Safe I/O with HALs
• GPIO input and output patterns and debouncing strategies
• Timers for delays, timekeeping, and periodic tasks
• Working with clocks and understanding impact on timing and power
• Structuring device drivers and separating hardware from application logic
Module 3: Serial and sensor communications
• UART for logs and simple protocols
• I2C and SPI transactions, addressing, and error handling
• Integrating a simple sensor or peripheral using an existing driver crate
• Tips for throughput, buffering, and backpressure
Module 4: Interrupts and task structure
• Interrupt safety, critical sections, and shared state patterns
• Concurrency models with RTIC or Embassy at a high level
• Using DMA where it simplifies timing and reduces CPU load
• Designing a small event loop with clear ownership boundaries
Module 5: On-target testing and debugging
• probe-rs workflow for flashing and breakpoints
• Reading logs and metrics on device with defmt
• Assert, unwrap, and error strategies that are safe on microcontrollers
• Capturing minimal traces for post-mortem analysis
Module 6: Power, performance, and robustness
• Sleep modes, clock gating, and practical power tips
• Handling faults, watchdogs, and brownout scenarios
• Memory use, stack sizing, and avoiding fragmentation
• Simple performance measurements and when to optimize
Module 7: Packaging and configuration management
• Reproducible builds, profiles, and linker settings
• Configuration via features and build-time parameters
• Versioning firmware and maintaining change notes
• Handing off artifacts and documentation for teammates
Module 8: Putting it together on a small application
• Define a minimal feature set and map to tasks and peripherals
• Wire up I/O, timing, and one communication channel
• Add logging, basic error recovery, and a simple health check
• Prepare a short checklist for flashing, smoke testing, and release
Hands-on learning with expert instructors at your location for organizations.
Master new skills guided by experienced instructors from anywhere.
