Introduzione a Rust su RP2350: panoramica generale

Post Views: 41

Negli ultimi anni, il linguaggio di programmazione Rust ha guadagnato popolarità tra gli sviluppatori di sistemi embedded grazie alla sua sicurezza, affidabilità e alle sue prestazioni ottimali. Rust è particolarmente apprezzato per il suo approccio innovativo alla gestione della memoria e per le sue capacità di prevenire errori di programmazione comuni. In questo articolo, esploreremo l’utilizzo di Rust sul RP2350, il nuovo chip della famiglia Raspberry Pi, analizzando i vantaggi, le sfide e le opportunità che questo linguaggio offre nel campo della programmazione embedded.

1. Cos’è il linguaggio Rust e perché è popolare per i sistemi embedded?

Rust è un linguaggio di programmazione moderno, progettato per essere sicuro e performante. Una delle sue caratteristiche distintive è il borrow checker, un sistema che impedisce problemi di concorrenza e gestione della memoria, due errori comuni nei linguaggi di basso livello come C e C++. Questa affidabilità ha reso Rust una scelta naturale per chi sviluppa software per sistemi embedded, dove è essenziale evitare crash o comportamenti imprevedibili dovuti a errori di memoria.

Oltre alla sicurezza, Rust offre anche prestazioni molto vicine a quelle del codice scritto in C/C++, senza però compromettere la produttività del programmatore. La combinazione di queste caratteristiche lo ha reso uno strumento ideale per microcontrollori e sistemi a risorse limitate, come i chip della famiglia Raspberry Pi.

2. Come viene utilizzato Rust per programmare il chip RP2350?

Il chip RP2350 è la nuova aggiunta alla linea di microcontrollori di Raspberry Pi, progettato per fornire elevate prestazioni e flessibilità, grazie a caratteristiche come il supporto per doppia architettura (Arm e RISC-V). Jonathan Pallant, esperto sviluppatore di Rust e appassionato di Raspberry Pi, ha condiviso le sue esperienze nello sviluppo di codice per il RP2350, dimostrando come Rust sia perfettamente in grado di gestire le funzionalità del chip.

Un esempio di codice Rust per far lampeggiare un LED su RP2350 è mostrato di seguito:

#![no_std]
#![no_main]

use panic_halt as _;
use rp235x_hal as hal;
use embedded_hal::digital::OutputPin;

#[hal::entry]
fn main() -> ! {
    let mut p = hal::pac::Peripherals::take().unwrap();
    let mut watchdog = hal::Watchdog::new(p.WATCHDOG);
    let clocks = hal::clocks::init_clocks_and_plls(
        12_000_000u32, p.XOSC, p.CLOCKS, p.PLL_SYS, p.PLL_USB, &mut p.RESETS, &mut watchdog,
    ).unwrap();
    let sio = hal::Sio::new(p.SIO);
    let pins = hal::gpio::Pins::new(p.IO_BANK0, p.PADS_BANK0, sio.gpio_bank0, &mut p.RESETS);
    let mut led_pin = pins.gpio25.into_push_pull_output();

    loop {
        led_pin.set_high().unwrap();
        hal::delay::Delay::new().delay_ms(500);
        led_pin.set_low().unwrap();
        hal::delay::Delay::new().delay_ms(500);
    }
}

#![no_std]

#![no_main]

use panic_halt as _;

use rp235x_hal as hal;

use embedded_hal::digital::OutputPin;

#[hal::entry]

fn main() -> ! {

let mut p = hal::pac::Peripherals::take().unwrap();

let mut watchdog = hal::Watchdog::new(p.WATCHDOG);

let clocks = hal::clocks::init_clocks_and_plls(

12_000_000u32, p.XOSC, p.CLOCKS, p.PLL_SYS, p.PLL_USB, &mut p.RESETS, &mut watchdog,

).unwrap();

let sio = hal::Sio::new(p.SIO);

let pins = hal::gpio::Pins::new(p.IO_BANK0, p.PADS_BANK0, sio.gpio_bank0, &mut p.RESETS);

let mut led_pin = pins.gpio25.into_push_pull_output();

loop {

led_pin.set_high().unwrap();

hal::delay::Delay::new().delay_ms(500);

led_pin.set_low().unwrap();

hal::delay::Delay::new().delay_ms(500);

}

Questo codice è un esempio di come Rust può essere utilizzato per gestire un’operazione comune come l’accensione e lo spegnimento di un LED su RP2350, utilizzando il Hardware Abstraction Layer (HAL) del chip.

3. I vantaggi di usare Rust su RP2350

Uno dei principali vantaggi nell’uso di Rust su RP2350 è la possibilità di scrivere codice efficiente e sicuro per un microcontrollore che supporta una vasta gamma di applicazioni embedded. Tra i benefici di Rust per questo tipo di sviluppo ci sono:

Sicurezza della memoria: Rust previene bug comuni come il buffer overflow o derefenziazioni di puntatori nulli, che possono causare il malfunzionamento di sistemi embedded critici.
Concorrenza senza rischi: La gestione dei thread e delle risorse condivise è semplificata e resa più sicura grazie al modello di proprietà di Rust.
Compatibilità multi-architettura: Il supporto per Arm e RISC-V consente di sviluppare software versatile e portabile tra diversi tipi di hardware.

4. Le sfide dello sviluppo con Rust su RP2350

Oltre alle periferiche già supportate, Pallant sta lavorando su diversi sviluppi chiave per rendere il supporto di Rust su RP2350 ancora più completo. Tra questi:

Secure Boot e Flash Partitions: Pallant sta anche lavorando sull’implementazione di Secure Boot, una funzione fondamentale per la sicurezza nei sistemi embedded, insieme al supporto per partizioni flash e altre caratteristiche avanzate del ROM di RP2350.
Driver per nuove periferiche: Includono il High Speed Transmitter (HSTX), il Power Manager (POWMAN) e l’encoder TMDS (Transition-Minimized Differential Signaling) del chip. Questi driver sono essenziali per sfruttare appieno le capacità avanzate del chip.
Supporto per PSRAM: Una delle funzionalità più promettenti è il supporto per la PSRAM, che consentirebbe al RP2350 di gestire fino a 16MB di RAM esterna. Questo aprirebbe nuove possibilità per applicazioni embedded che richiedono una maggiore capacità di memoria.

Inoltre, una parte significativa del lavoro riguarda l’aggiornamento delle librerie di supporto Rust per RISC-V, in modo da permettere ai programmi di dichiarare gestori di interrupt sia per la modalità RISC-V che per ARM, senza richiedere modifiche al codice sorgente.

5. Come iniziare a programmare con Rust su RP2350?

Se sei interessato a iniziare a programmare con Rust su RP2350, il primo passo è familiarizzare con il pacchetto rp-hal, una libreria che fornisce supporto per l’interazione con l’hardware della serie Raspberry Pi. Puoi trovare esempi e risorse su GitHub, e partecipare alle discussioni della community su Matrix, una piattaforma open-source simile a Discord, che offre supporto a chiunque voglia intraprendere questo percorso.

In conclusione, Rust offre un’ottima combinazione di potenza, sicurezza e versatilità, rendendolo una scelta ideale per la programmazione su sistemi embedded come RP2350. Con una comunità in continua crescita e un supporto sempre maggiore da parte di sviluppatori e aziende, Rust potrebbe diventare lo standard per lo sviluppo embedded nei prossimi anni.

Jonathan Pallant (@therealjpster) is a huge programming fan, just like the Rust of us… get it…? In today’s blog, he tells us a little bit about the Rust programming language and what he's managed to get working on our new chip, RP2350, so far.

You can also read on to discover… pic.twitter.com/nLToRBeBUB

— Raspberry Pi (@Raspberry_Pi) September 6, 2024

6. Stato di sviluppo di Rust su RP2350

Da una discussione su Reddit emergono interessanti punti di vista.

Dal punto di vista del supporto attuale per RP2350, viene menzionato che Rust per RP2350 è ancora in fase di sviluppo, con librerie come Embassy che stanno lavorando per fornire pieno supporto. Tuttavia, gli utenti indicano che c’è già un’ampia documentazione e risorse per il RP2040, e il passaggio a RP2350 non dovrebbe essere complesso una volta completato il supporto. L’utente fstephany menziona un blog post recente (forse quello di Jonathan Pallant) che aggiorna sul progresso del supporto Rust per RP2350.

Questo ci aiuta a sottolineare che, mentre RP2350 è un’opzione interessante per il futuro, al momento gli sviluppatori Rust potrebbero voler cominciare con RP2040 per poi effettuare la migrazione quando il supporto per RP2350 sarà completamente maturo.

Nella discussione si evidenzia anche il fatto che, pur essendo l’ESP32 una piattaforma valida per lo sviluppo embedded (specialmente per via del suo costo inferiore e del supporto nativo WiFi), la community Raspberry Pi sembra essere più attiva e con una maggiore disponibilità di risorse per chi programma in Rust, soprattutto se si tratta di RP2040 e RP2350.

Jonathan Pallant di Ferrous Systems ha ottenuto accesso anticipato al chip RP2350, montato su una versione pre-produzione del Raspberry Pi Pico 2, con l’obiettivo di testare e migliorare il supporto di Rust. Il suo lavoro ha già portato a notevoli successi, con molte periferiche chiave del chip portate su Rust, come:

SPI (Serial Peripheral Interface)
UART (Universal Asynchronous Receiver-Transmitter)
I2C (Inter-Integrated Circuit)
GPIO (General-Purpose Input/Output)
DMA (Direct Memory Access)

Inoltre, Pallant è riuscito a implementare la lettura della memoria OTP (One-Time Programmable) sia con che senza ECC (Error Correction Code), e ha sfruttato le routine del ROM per interagire con il chip.

Tuttavia, nonostante i progressi, il supporto di Rust su RP2350 non è ancora completo. Una delle principali sfide tecniche è legata al debugging tramite l’interfaccia ARM Debug Interface v6. Questo strumento, che funziona perfettamente con il RP2040 e molti altri microcontrollori, non è ancora compatibile con RP2350, poiché l’interfaccia ARM del chip è troppo recente per essere riconosciuta dai tool di debugging come probe-rs.

Iscriviti ai nostri gruppi Telegram

Link utili

Seguici per non perdere le prossime novità!

Simone Candido

Simone Candido è un ragazzo appassionato del mondo tech nella sua totalità. Simone ama immedesimarsi in nuove esperienze, la sua filosofia si basa sulla irrefrenabile voglia di ampliare a 360° le sue conoscenze abbracciando tutti i campi del sapere, in quanto ritiene che il sapere umano sia il connubio perfetto tra cultura umanistica e scientifica.

Moreware Blog

Mindware site for Raspberry PI and Arduino prototyping