PricingLoginStart free
Learn Rust Coding · Aula

Introdução ao Rust Integrado

Comece a utilizar Rust Integrado, compreendendo a cadeia de ferramentas, as placas de desenvolvimento comuns e os fundamentos da programação sem sistema operativo.

Aula 1 de 311 etapas

Introdução ao Rust Integrado é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 3 aulas no total.

Boas-vindas ao Rust Embarcado

Boas-vindas ao mundo do Rust Embarcado! Esta lição dará início à sua jornada na programação de microcontroladores e outros dispositivos com recursos limitados usando Rust.

Vamos explorar por que Rust é uma excelente escolha para sistemas embarcados e o que torna esse domínio único em comparação com o desenvolvimento tradicional para computadores ou para a web.

Rust Embarcado vs. Rust Padrão

Ao programar para sistemas embarcados, muitas vezes você trabalha sem um sistema operacional. Isso significa que você interage diretamente com o hardware.

  • Sem OS: Sem Linux, Windows ou macOS.
  • Restrições de recursos: Memória (RAM) e armazenamento (Flash) limitados.
  • Hardware direto: Você controla diretamente periféricos como GPIOs, temporizadores e interfaces de comunicação.

A cadeia de ferramentas do Rust Embarcado

Para começar, é necessária uma configuração um pouco diferente da usada no Rust padrão. Normalmente, você usará rustup para instalar componentes específicos:

  • Suporte ao destino: Por exemplo, rust-std-arm-none-eabi para microcontroladores ARM Cortex-M.
  • cargo-generate: Uma ferramenta para criar novos projetos a partir de modelos, algo comum em configurações embarcadas.
  • Ferramentas de depuração: Como probe-rs para gravar o firmware e depurar o dispositivo.

Fundamentos da compilação cruzada

O desenvolvimento embarcado frequentemente envolve compilação cruzada. Isso significa compilar seu código em um tipo de computador (por exemplo, o CPU x86 do seu laptop) para executá-lo em outro (por exemplo, um microcontrolador ARM Cortex-M).

Rust usa triplas de destino (por exemplo, thumbv7em-none-eabihf) para especificar a arquitetura, o fornecedor, o OS (ou a ausência dele) e o ABI do dispositivo de destino.

Placas de desenvolvimento comuns

Você encontrará vários microcontroladores (MCUs) no Rust embarcado. Entre as opções populares estão:

  • Série STM32: Versátil e amplamente usada na indústria.
  • ESP32: Conhecido pelos recursos de Wi-Fi e Bluetooth.
  • Série nRF52: Excelente para aplicações de Bluetooth Low Energy (BLE).

Essas placas fornecem o hardware físico no qual seu código Rust será executado.

Entendendo a programação bare-metal

A programação bare-metal significa que seu código é executado diretamente no hardware, sem um sistema operacional subjacente para gerenciar recursos ou fornecer abstrações.

Você é responsável por tudo: inicializar a memória, configurar o relógio, configurar os periféricos e tratar as interrupções. É um nível baixo de programação, mas oferece controle total.

Estrutura de um programa bare-metal

Um programa Rust embarcado tem uma aparência diferente de um programa padrão. Veja uma estrutura básica:

  • #![no_std]: Não vincula a biblioteca padrão.
  • #![no_main]: Não usa o ponto de entrada padrão main.
  • #[cortex_m_rt::entry]: Especifica o ponto de entrada real para dispositivos Cortex-M.

Esse programa mínimo seria compilado para um destino embarcado, mas requer um tratador de pânico e uma biblioteca de execução.

#![no_std]
#![no_main]

// A minimal panic handler for embedded systems
use panic_halt as _;

// The entry point for ARM Cortex-M microcontrollers
#[cortex_m_rt::entry]
fn main() -> ! {
    // This function runs once on device startup.
    // Here you would initialize your hardware peripherals.
    // For example, setting up a GPIO pin.

    loop {
        // Your main application loop runs here.
        // This loop will run forever, performing tasks.
        // Example: Toggle an LED, read sensor data.
    }
}

O “Olá, mundo!” do mundo embarcado

Como não há um console para imprimir, o clássico "Hello, World!" dos sistemas embarcados normalmente é fazer um LED piscar.

Esse ato simples demonstra que você conseguiu:

  • Compilar seu código para o destino.
  • Gravá-lo no dispositivo.
  • Obter controle sobre um periférico básico de hardware (um pino de entrada/saída de uso geral).

Organização da memória e scripts do vinculador

Na programação bare-metal, você precisa entender como o código compilado e os dados do seu programa são organizados na memória do microcontrolador.

Os scripts do vinculador (geralmente fornecidos pelos pacotes de suporte à placa) definem essa organização da memória, especificando onde ficam as diferentes seções do seu programa (por exemplo, código, dados estáticos, heap e pilha) na memória Flash (somente leitura) e RAM (leitura e gravação) do dispositivo.

Verificação rápida dos fundamentos do mundo embarcado

Vamos verificar seu entendimento dos fundamentos do Rust embarcado.

Responda na aula interativa

Recapitulação: começando com Rust embarcado

Nesta lição, apresentamos o Rust Embarcado, destacando seus desafios únicos, como a programação bare-metal e a compilação cruzada. Abordamos os componentes essenciais da cadeia de ferramentas, as placas de desenvolvimento comuns e a estrutura fundamental de um programa no_std.

Você também aprendeu que fazer um LED piscar é o equivalente embarcado de "Hello, World!" e teve uma introdução aos scripts do vinculador. Agora você está pronto para se aprofundar na escrita de código para o mundo real!

Grátis para começar

Aprenda Rust com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
39
Aulas
144
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Introdução ao Rust Integrado” é grátis?

Sim — o texto completo de “Introdução ao Rust Integrado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 3 aulas no total.

O que vou aprender em “Introdução ao Rust Integrado”?

Comece a utilizar Rust Integrado, compreendendo a cadeia de ferramentas, as placas de desenvolvimento comuns e os fundamentos da programação sem sistema operativo. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “Introdução ao Rust Integrado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Introdução ao Rust Integrado
  2. HALs e Controladores de Dispositivos
  3. Conceitos de Desenvolvimento de Sistemas Operativos
← Voltar para Learn Rust Coding