Rust invade o mundo embedded: por que C não é mais o rei

Introdução: A era do "hardware" muda de linguagem

Se você já escreveu um firmware para microcontrolador em C, conhece esse sentimento. Aquele sentimento de que, após três horas de depuração, você encontra um travamento — o ponteiro voou para o espaço, e o watchdog aguentou tudo. O desenvolvimento embedded por muitos anos foi território do C e do assembly. Mas nos últimos anos, um novo jogador entrou em cena — Rust. E ele não é apenas "mais uma linguagem", mas sim um verdadeiro avanço para sistemas embarcados.

Neste artigo, vamos analisar por que o desenvolvimento embedded em Rust não é moda, mas sim uma necessidade. Veremos exemplos reais de código, compararemos com C e entenderemos por onde começar. Se você programa para STM32, ESP32 ou ARM Cortex-M, este artigo é para você.

Por que Rust para embedded é o casamento ideal

Sistemas embarcados são um mundo de limitações. Pouca memória, sem SO, sem heap, sem exceções. Erro de compilação é bom, erro em tempo de execução é ruim. Rust foi projetado exatamente para essas condições.

Segurança de memória sem coletor de lixo

A principal dor do desenvolvedor embedded em C é use-after-free, dupla liberação de memória e estouro de buffer. O Rust resolve isso no nível dos tipos. O modelo de ownership e borrowing funciona mesmo em ambiente no_std — sem alocador, sem SO, sem GC.

Imagine que você está escrevendo um driver para um LED. Em C, você escreveria:

// C code\nvoid led_on(GPIO_TypeDef *gpio, uint16_t pin) {\n    gpio->BSRR = pin;\n}

Tudo bem, até que alguém passe um ponteiro nulo. Rust não permite que você faça isso:

// Rust code\nfn led_on(gpio: &mut GpioRegisters, pin: u16) {\n    gpio.bsrr.write(|w| w.bits(pin.into()));\n}

Aqui, &mut GpioRegisters é a garantia de que a referência é válida e o acesso aos registradores é exclusivo. O compilador simplesmente não deixará passar código perigoso.

Abstrações de custo zero

Um dos maiores medos dos desenvolvedores embedded é que uma linguagem de alto nível "consuma" ciclos de processador. Rust segue o princípio de zero-cost abstractions: você paga apenas pelo que usa. Iteradores, closures, traits — tudo isso é compilado em código de máquina tão eficiente quanto a descompactação manual de loops em C.

Além disso, no ecossistema embedded do Rust, existem crates que operam no nível de instruções individuais. Por exemplo, cortex-m-rt gera o vetor de interrupções e o código de inicialização sem uma única instrução extra.

Projeto real: piscando um LED em Rust (STM32)

Vamos escrever um programa simples para a placa STM32F3Discovery. Usaremos cortex-m-quickstart e o HAL da comunidade embedded rust.

Passo 1: Configuração do projeto

Certifique-se de ter o Rust e a toolchain para ARM Cortex-M instalados:

rustup target add thumbv7em-none-eabihf\ncargo install cargo-generate

Crie o projeto a partir do template:

cargo generate --git https://github.com/rust-embedded/cortex-m-quickstart

Passo 2: Escrevendo o código

Abra src/main.rs e escreva o clássico Blinky:

#![no_std]\n#![no_main]\n\nuse cortex_m_rt::entry;\nuse panic_halt as _;\nuse stm32f3xx_hal::{pac, prelude::*};\n\n#[entry]\nfn main() -> ! {\n    // Obtém acesso à periferia\n    let dp = pac::Peripherals::take().unwrap();\n    let mut rcc = dp.RCC.constrain();\n    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);\n\n    // Configura o pino PE9 como saída (LED LD1)\n    let mut led = gpioe\n        .pe9\n        .into_push_pull_output(&mut gpioe.moder, &mut gpioe.otyper);\n\n    loop {\n        led.set_high().unwrap();\n        cortex_m::asm::delay(8_000_000);\n        led.set_low().unwrap();\n        cortex_m::asm::delay(8_000_000);\n    }\n}

O que está acontecendo aqui?

\n
• #![no_std] — estamos n