Technologie / Programowanie

Rust dla systemów wbudowanych — programowanie bare metal, peryferia i RTOS

Trzydniowe szkolenie Rust embedded — no_std, bare metal, HAL (Hardware Abstraction Layer), GPIO/SPI/I2C/UART, przerwania, DMA, RTOS (embassy), zarządzanie energią, OTA updates, debugowanie (probe-rs, defmt).

Rust embedded to nie „Rust z flagą no_std” — to inny ekosystem, inne wzorce, inna diagnostyka

Znasz Rust? Ownership, borrowing, traits — OK. Ale embedded Rust to: no_std (brak standardowej biblioteki), bare metal (brak OS), linker script (definiujesz układ pamięci ręcznie), PAC (Peripheral Access Crate — wygenerowany z SVD), embedded-hal (trait-based hardware abstraction), przerwania z critical sections (nie mutex z std), async bez runtime’u (embassy). C embedded → Rust embedded to nie „przepisz z C na Rust”. To nauka NOWEGO ekosystemu z innymi narzędziami i wzorcami.

Trzydniowe szkolenie: od ekosystemu Rust embedded (no_std, cortex-m, embedded-hal, konfiguracja środowiska) i peryferiów (GPIO, UART, SPI, I2C, debugowanie z probe-rs/defmt), przez przerwania (NVIC, DMA, critical sections), async embedded (embassy/RTIC, task scheduling, zarządzanie energią), po sterowniki urządzeń (driver crates, czujniki, ADC/PWM), komunikację bezprzewodową (BLE, WiFi, LoRa), OTA updates (MCUboot, podpisy cyfrowe) i bezpieczeństwo (secure boot, memory safety).

Dla kogo jest to szkolenie?

Dla programistów wchodzących w Rust embedded. Szczególnie gdy:

Programujesz mikrokontrolery w C/C++ i chcesz przejść na Rust — dla memory safety bez utraty wydajności
Znasz Rust (std) ale nie masz doświadczenia embedded — szkolenie daje wiedzę o no_std, peryferiach i RTOS
Budujesz urządzenia IoT i potrzebujesz bezpiecznego firmware — OTA updates, secure boot, anti-tampering

Trzy dni: od bare metal do OTA updates

Dzień 1: Bare metal i peryferia — ekosystem (no_std, embedded-hal), konfiguracja (toolchain, linker script), startup bare metal, GPIO (typesafe API), komunikacja (UART, SPI, I2C), debugowanie (probe-rs, defmt, RTT).

Dzień 2: Przerwania i RTOS — system przerwań (NVIC, priorytety, critical sections), DMA (kanały, double buffering), async embedded (embassy/RTIC, task scheduling), współbieżność (channels, atomics), zarządzanie energią (sleep modes), watchdog i fault handling.

Dzień 3: Sterowniki i produkcja — pisanie driver crates (embedded-hal traits), czujniki (ADC, PWM, DAC), komunikacja bezprzewodowa (BLE, WiFi, LoRa), OTA updates (MCUboot, podpisy, rollback), testowanie (no_std tests, HIL), bezpieczeństwo (secure boot).

Z ponad 2500 szkoleń w ofercie i oceną 4.8/5, EITT jest zaufanym partnerem w rozwoju kompetencji. Skontaktuj się z nami — organizujemy szkolenia Rust embedded zamknięte dla zespołów firmware i IoT.

Korzyści

Konfigurować środowisko Rust embedded — toolchain, cargo, linker script, debugger (probe-rs)
Programować mikrokontrolery w Rust bare metal — GPIO, UART, SPI, I2C z typesafe API
Implementować system przerwań i DMA — NVIC, priorytety, critical sections, double buffering
Stosować async embedded Rust (embassy/RTIC) — task scheduling, async I/O, zarządzanie energią
Pisać reużywalne sterowniki urządzeń z embedded-hal traits
Wdrażać OTA firmware updates — bootloader, podział flash, podpisy cyfrowe, rollback

Dla kogo jest to szkolenie?

Programiści embedded (C/C++) chcący przejść na Rust dla bezpieczeństwa pamięci

Inżynierowie firmware szukający nowoczesnego języka do programowania mikrokontrolerów

Deweloperzy Rust chcący wejść w świat systemów wbudowanych (bare metal)

Specjaliści IoT budujący urządzenia z ograniczonymi zasobami

Inżynierowie automatyki i robotyki programujący sterowniki i kontrolery

Architekci systemów embedded planujący migrację z C na Rust

Wymagania wstępne

Znajomość języka Rust — ownership, borrowing, lifetime, traits, generics
Podstawowa wiedza o elektronice cyfrowej — sygnały cyfrowe, interfejsy (GPIO, SPI, I2C)
Doświadczenie w programowaniu niskopoziomowym (C/C++ embedded lub Rust)
Rozumienie architektury mikrokontrolerów — rejestry, pamięć flash/RAM, peryferia

Program szkolenia

Ekosystem Rust embedded — no_std, cortex-m, embedded-hal, PAC (Peripheral Access Crate)
Konfiguracja środowiska — toolchain (thumbv7em), cargo, linker script, memory.x, .cargo/config
Bare metal Rust — startup, vector table, panic handler, alloc vs no-alloc
GPIO — konfiguracja pinów (input/output/alternate), pull-up/pull-down, typesafe pin API
Komunikacja szeregowa — UART (konfiguracja, bufory), SPI (master/slave, DMA), I2C
Debugowanie — probe-rs, defmt (zero-cost logging), RTT, GDB, semihosting

System przerwań — NVIC, priorytety, critical sections (cortex-m), interrupt-safe data sharing
DMA (Direct Memory Access) — konfiguracja kanałów, transfer circular, double buffering
RTIC/embassy — async embedded Rust, task scheduling, timer-based events, async I/O
Wzorce współbieżności — mutex (CriticalSection), channels, atomics w embedded
Zarządzanie energią — sleep modes, wake-up sources, tick-less scheduling
Watchdog i fault handling — IWDG, hardfault handler, stack overflow detection

Pisanie sterowników urządzeń — embedded-hal traits, driver crates, reużywalność
Czujniki i aktuatory — ADC, PWM, DAC — kalibracja, filtrowanie, sterowanie
Komunikacja bezprzewodowa — BLE (nRF), WiFi (ESP32), LoRa — integracja z Rust
OTA firmware updates — bootloader (MCUboot), podział flash, podpisy cyfrowe, rollback
Testowanie embedded — unit testy (no_std), HIL (Hardware-in-the-Loop), defmt-test
Bezpieczeństwo — memory safety (ownership, borrowing), secure boot, anti-tampering

Formy realizacji

Online

Wygoda uczestnictwa z dowolnego miejsca
Interaktywne sesje na żywo z trenerem
Materiały dostępne przez 30 dni
Brak kosztów dojazdu

Stacjonarnie

Bezpośredni kontakt z trenerem i grupą
Intensywne warsztaty praktyczne
Networking z innymi uczestnikami
Pełne skupienie na nauce

Tematy szkolenia

Najczęściej zadawane pytania

Dlaczego Rust zamiast C w embedded?

Memory safety BEZ garbage collectora. W C — buffer overflow, use-after-free, dangling pointers to norma (i źródło CVE). Rust eliminuje te klasy błędów na etapie kompilacji (ownership, borrowing). Zero-cost abstractions = ten sam kod maszynowy co C, ale bezpieczniejszy. Ekosystem embedded Rust (embedded-hal, embassy) jest produkcyjny od 2023+.

Na jakim mikrokontrolerze pracujemy?

Szkolenie oparte na ARM Cortex-M (STM32 lub nRF52) — najpopularniejsza platforma embedded Rust. Koncepcje (embedded-hal, RTIC/embassy) są przenośne na inne MCU (ESP32, RISC-V). Ćwiczenia na emulatorze QEMU lub fizycznym devboard.

Czy muszę znać C embedded?

Nie wymagamy — ale pomaga. Musisz znać Rust (ownership, traits, generics) i rozumieć czym jest GPIO, przerwanie, rejestr. Jeśli znasz C embedded — szkolenie pokaże jak te same koncepcje wyglądają w Rust (bezpieczniej i ergonomiczniej).

W jakim formacie i jak długo trwa szkolenie?

Szkolenie trwa 3 dni (9:00-16:00), dostępne online i stacjonarnie. Warsztaty z programowaniem mikrokontrolerów w Rust.

Czy po szkoleniu otrzymam certyfikat?

Tak, każdy uczestnik otrzymuje imienny certyfikat ukończenia szkolenia wydany przez EITT.