embassy-rs/embassy: Framework incorporado moderno, usando Rust e async.

Embassy é a estrutura de próxima geração para aplicativos incorporados. Escreva código incorporado seguro, correto e com baixo consumo de energia com mais rapidez, usando a linguagem de programação Rust, seus recursos assíncronos e as bibliotecas Embassy.

A linguagem de programação Rust é extremamente rápida e eficiente em termos de memória, sem tempo de execução, coletor de lixo ou sistema operacional. Ele detecta uma grande variedade de bugs em tempo de compilação, graças à sua total segurança de memória e thread e sistema de tipos expressivos.

O async/await do Rust permite multitarefa fácil e eficiente sem precedentes em sistemas embarcados. As tarefas são transformadas em tempo de compilação em máquinas de estado que são executadas cooperativamente. Ele não requer alocação dinâmica de memória e é executado em uma única pilha, portanto, nenhum ajuste de tamanho de pilha por tarefa é necessário. Ele torna obsoleta a necessidade de um RTOS tradicional com troca de contexto de kernel e é mais rápido e menor que um!

• Camadas de abstração de hardware

  • HALs implementam APIs Rust idiomáticas e seguras para usar os recursos de hardware, portanto, a manipulação de registro bruto não é necessária. O projeto Embassy mantém HALs para hardware selecionado, mas você ainda pode usar HALs de outros projetos com Embassy.
  • embassy-stm32, para todas as famílias de microcontroladores STM32.
  • embassy-nrf, para as séries Nordic Semiconductor nRF52, nRF53, nRF54 e nRF91.
  • embassy-rp, para os microcontroladores Raspberry Pi RP2040 e RP23xx.
  • embassy-mspm0, para os microcontroladores MSPM0 da Texas Instruments.
  • esp-rs, para a série de chips ESP32 da Espressif Systems.
    • O suporte Embassy HAL para chips Espressif, bem como Async Wi-Fi, Bluetooth e ESP-NOW, está sendo desenvolvido no repositório esp-rs/esp-hal.
  • ch32-hal, para a série de chips WCH RISC-V (CH32V) de 32 bits.
  • mpfs-hal, para o SoC Microchip PolarFire.
  • py32-hal, para a série de microcontroladores Puya Semiconductor PY32.

• Tempo que simplesmente funciona – Chega de mexer com temporizadores de hardware. embassy_time fornece os tipos Instant, Duration e Timer que estão disponíveis globalmente e nunca transbordam.

• Pronto em tempo real – As tarefas no mesmo executor assíncrono são executadas cooperativamente, mas você pode criar vários executores com prioridades diferentes para que as tarefas de prioridade mais alta previnam as de prioridade mais baixa. Veja o exemplo.

• Pronto para baixo consumo de energia – Construa facilmente dispositivos com anos de bateria. O executor assíncrono coloca automaticamente o núcleo em suspensão quando não há trabalho a fazer. As tarefas são despertadas por interrupções, não há sondagem de loop ocupado durante a espera.

• Rede – A pilha de rede embassy-net implementa ampla funcionalidade de rede, incluindo Ethernet, IP, TCP, UDP, ICMP e DHCP. O Async simplifica drasticamente o gerenciamento de tempos limite e o atendimento a múltiplas conexões simultaneamente.

• Bluetooth

  • A caixa de problemas fornece um host Bluetooth Low Energy 4.xe 5.x que roda em qualquer microcontrolador que implemente as características bt-hci (atualmente
    nRF52, nrf54, rp2040, rp23xx e esp32 e serial controladores são suportados).
  • A caixa nrf-softdevice fornece suporte Bluetooth Low Energy 4.xe 5.x para microcontroladores nRF52.
  • A caixa embassy-stm32-wpan fornece suporte Bluetooth Low Energy 5.x para microcontroladores stm32wb.

• LoRa – O projeto lora-rs fornece uma pilha LoRa e LoRaWAN assíncrona que funciona bem no Embassy.

• USB – embassy-usb implementa uma pilha USB no lado do dispositivo. Estão disponíveis implementações para classes comuns, como USB serial (CDC ACM) e USB HID, e uma rica API de construtor permite criar a sua própria.

• Bootloader e DFU – embassy-boot é um bootloader leve que suporta atualizações de aplicativos de firmware de maneira à prova de falhas de energia, com inicializações de teste e reversões.

use defmt::info;
use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull};
use embassy_nrf::{Peri, Peripherals};

// Declare async tasks
#[embassy_executor::task]
async fn blink(pin: Peri<'static, AnyPin>) {
    let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);

    loop {
        // Timekeeping is globally available, no need to mess with hardware timers.
        led.set_high();
        Timer::after_millis(150).await;
        led.set_low();
        Timer::after_millis(150).await;
    }
}

// Main is itself an async task as well.
#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_nrf::init(Default::default());

    // Spawned tasks run in the background, concurrently.
    spawner.spawn(blink(p.P0_13.into()).unwrap());

    let mut button = Input::new(p.P0_11, Pull::Up);
    loop {
        // Asynchronously wait for GPIO events, allowing other tasks
        // to run, or the core to sleep.
        button.wait_for_low().await;
        info!("Button pressed!");
        button.wait_for_high().await;
        info!("Button released!");
    }
}

Exemplos são encontrados no
examples/ pasta separada pelo fabricante do chip em que foram projetados para serem executados. Por exemplo:

• examples/nrf52840 correr no
  nrf52840-dk placa (PCA10056), mas deve ser facilmente adaptável a outros chips e placas nRF52.
• examples/nrf5340 correr no nrf5340-dk placa (PCA10095).
• examples/stm32xx para as diversas famílias STM32.
• examples/rp são para o chip RP2040.
• examples/std são projetados para serem executados localmente em seu PC.

• Instalar probe-rs seguindo as instruções em https://probe.rs.
• Mude o diretório para o diretório base da amostra. Por exemplo:

• Garantir Cargo.toml define o recurso correto para o nome do chip que você está programando. Se este nome estiver incorreto, o exemplo poderá falhar na execução ou travar imediatamente após ser programado.

• Garantir .cargo/config.toml contém o nome do chip que você está programando.

• Execute o exemplo

Por exemplo:

cargo run --release --bin blinky

Para obter mais ajuda para começar, consulte Introdução e execução dos exemplos.

O Rust Analyzer é usado pelo Visual Studio Code e outros. Dados os vários alvos que o Embassy atende, não há arquivo de espaço de trabalho Cargo. Em vez disso, o Rust Analyzer deve ser informado sobre o projeto alvo com o qual trabalhar. No caso do Visual Studio Code, consulte o .vscode/settings.json arquivo rust-analyzer.linkedProjectscontexto.

O Embassy tem garantia de compilação em Rust estável 1.75 e superior. Isto poder
compilar com versões mais antigas, mas isso pode mudar em qualquer novo lançamento de patch.

ASYnc incorporado! 🙂

A Embassy está licenciada sob qualquer um dos

a sua opção.

A menos que você declare explicitamente o contrário, qualquer contribuição enviada intencionalmente para inclusão no trabalho por você, conforme definido na licença Apache-2.0, deverá ser licenciada duplamente conforme acima, sem quaisquer termos ou condições adicionais.