+49 (0) 30 2207 8911
info@orb-experts.com
A practical, hardware focused course that builds confident embedded development with Rust. The first two days establish project setup, peripherals, timing, and reliable on-device debugging. The third day adds optimization, resilient error paths, deployment practices, and core security.
You will set up no_std projects, work safely with vendor HALs, and structure drivers with clear ownership. You will test and debug on target, reason about power and memory, and package firmware for teammates. You will optimize critical paths, harden error handling, plan updates, and apply essential security.
• Build and debug embedded Rust applications with HALs, timers, interrupts, and DMA
• Design small, reliable application structures with logging, recovery, and health checks
• Optimize for size and speed while managing power, memory, and concurrency risks
• Plan provisioning, updates, and secure communication for deployed devices
• Comfortable with Rust basics and cargo
• Experience with microcontrollers and Linux or macOS shell
• Access to a supported board, probe, and toolchain
*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
Module 9: Firmware optimization techniques
• Measuring hotspots with cycle counters, timestamps, and lightweight probes
• Cargo profiles, LTO, panic=abort, codegen units, and size versus speed tradeoffs
• Hot path cleanup remove busy waits, prefer DMA, tune interrupt priorities
• Zero cost patterns avoid allocation, leverage inlining and static dispatch
Module 10: Robust error handling for devices
• no_std friendly error types Result, custom enums, and minimal codes
• Non-panicking APIs retries, backoff, and bounded queues
• Centralized reporting health flags, counters, and sparse telemetry
• Safe recovery strategies watchdog resets, limp modes, and persisted fault markers
Module 11: Deployment, updates, and diagnostics
• Bootloader options and A/B slots with versioning discipline
• Update channels wired, field, or OTA requirements and constraints
• Settings and persistence layouts wear leveling basics and schema evolution
• Provisioning at scale unique IDs, keys, and reproducible flashing checklists
Module 12: Security essentials on microcontrollers
• Threat modeling for embedded surfaces debug, firmware, communication, storage • Hardening build and runtime cargo audit, clippy, unsafe reviews, MPU if available • Cryptography basics vetted crates, RNG, key handling, timing awareness • Secure communication and access lock down debug ports, secure boot prerequisites, certificate or token based pairing
Hands-on learning with expert instructors at your location for organizations.
Master new skills guided by experienced instructors from anywhere.
You can participate in a Public Course with people from other organisations.
/per trainee
