Rusty Flying Robots: Learning a Full Robotics Stack with Real-Time Operation on an STM32 Microcontroller in a 9 ECTS MS Course

Questo articolo descrive un innovativo corso magistrale in cui gli studenti implementano un'intera pila robotica, dalla dinamica alla pianificazione, utilizzando il linguaggio di programmazione Rust su una microcontroller STM32 per far volare robot reali, evitando infrastrutture software predefinite per favorire un apprendimento pratico e profondo.

L'essenziale

Immagina di dover insegnare a un gruppo di studenti come far volare un drone, ma con una regola ferrea: niente scorciatoie. Niente "scatole nere" già pronte, niente software magico che fa tutto da solo. Devono costruire tutto da zero, dal motore che fa volare il drone fino al cervello che decide dove andare, e devono farlo funzionare su un piccolo chip elettronico che ha meno memoria di un vecchio telefono tascabile.

Questo è il cuore del corso universitario descritto nel paper: "Rusty Flying Robots" (Robot Volanti Rugginosi, un gioco di parole sul linguaggio di programmazione Rust).

Ecco come funziona, spiegato con parole semplici e qualche analogia:

1. Il Problema: La Dilemma dell'Insegnamento

Di solito, insegnare la robotica è un dilemma per i professori:

• Se usi linguaggi semplici (come Python), gli studenti fanno cose belle ma non funzionano sulla robotica vera (che richiede velocità e precisione).
• Se usi linguaggi complessi (come C o C++), gli studenti passano mesi a scrivere codice per far funzionare le cose di base, senza mai imparare la robotica vera.
• Se usi solo simulazioni al computer, è sicuro ma noioso: non c'è l'adrenalina di vedere il robot muoversi davvero.

Gli autori hanno detto: "Basta compromessi". Vogliono che gli studenti facciano tutto: dalla teoria alla pratica, su un vero drone, ma usando un linguaggio moderno chiamato Rust.

2. La Soluzione: Rust come "Coltellino Svizzero"

Perché Rust? Immagina che Rust sia un coltellino svizzero per la programmazione.

• È veloce come un'auto da corsa (come il C/C++).
• È sicuro come un'auto con airbag e cinture di sicurezza che non ti fanno sbattere (a differenza del C, che spesso fa crashare i programmi se sbagli una virgola).
• È abbastanza potente da girare sia sul tuo computer potente (per simulare) sia sul minuscolo chip del drone (STM32).

Il bello è che gli studenti, anche se non lo conoscevano prima, hanno imparato a usarlo e sono riusciti a far volare il drone in tempo reale.

3. Il Percorso: Costruire il Drone "Mattoncino per Mattoncino"

Il corso è diviso in quattro grandi sfide, come i livelli di un videogioco:

• Livello 1: La Simulazione (Il Mondo Virtuale)
  Prima di toccare il drone vero, gli studenti devono scrivere un simulatore. Non usano software già fatti come Gazebo. Devono scrivere le leggi della fisica (gravità, rotazione, velocità) da zero.

  • Analogia: È come se, prima di guidare una Ferrari, dovessi costruire tu stesso il motore e il telaio su carta, calcolando ogni singola forza. Se sbagli un calcolo, il simulatore non funziona. Questo insegna davvero come si muove un drone.

• Livello 2: Il Controllore (Il Pilota)
  Qui gli studenti scrivono il codice che dice al drone come muoversi per seguire una traiettoria. Usano matematica complessa (non lineare) che i droni moderni usano davvero.

  • La sfida: Devono far funzionare questo codice sul chip del drone. Se sbagli anche solo un decimale, il drone impazzisce e si schianta in millisecondi. È come guidare un'auto su una corda tesa: un errore e cadi.

• Livello 3: La Stima dello Stato (Gli Occhi)
  Il drone non sa dove si trova da solo. Deve guardare i suoi sensori (giroscopi, accelerometri) e capire: "Dove sono? Sto cadendo? Sto girando?".

  • La sfida: I sensori sono rumorosi e imperfetti. Gli studenti devono creare un filtro matematico (un "cervello" che pulisce i dati) per capire la realtà. È come cercare di ascoltare una conversazione in una stanza piena di gente che urla: devi filtrare il rumore per capire le parole.

• Livello 4: La Pianificazione (La Mappa)
  Infine, il drone deve decidere come volare attraverso ostacoli stretti o fare manovre aggressive.

  • La sfida: Devono calcolare il percorso perfetto in pochi millisecondi, usando un chip molto limitato. È come se dovessi pianificare un viaggio in auto mentre guidi a 200 km/h, senza poter guardare la mappa per più di un secondo.

4. Il Risultato: Funziona!

Il corso è stato tenuto due volte con 10 studenti ciascuno.

• Tempo: Hanno lavorato circa 6-9 ore a settimana (molto per un corso, ma ne è valsa la pena).
• Soddisfazione: Gli studenti hanno dato voti altissimi (1.1 su 5, dove 1 è il massimo). Hanno detto: "È stato uno dei corsi più divertenti e formativi".
• La sorpresa: Anche se Rust era nuovo per tutti, non è stato un problema. Anzi, è stato una sfida motivante. Hanno imparato a programmare, a fare matematica e a gestire l'hardware tutto in uno.

In Sintesi

Questo corso è come un laboratorio di ingegneria estremo. Invece di dare agli studenti un'auto già montata e chiedergli di guidarla, gli dai un mucchio di pezzi di metallo, un manuale di fisica e li sfidi a costruire l'auto, il motore e il sistema di navigazione, e poi a farla correre su un circuito reale.

Usando il linguaggio Rust, hanno dimostrato che è possibile insegnare robotica avanzata senza "scorciatoie", creando ingegneri che capiscono davvero come funziona la magia del volo, dal codice al metallo.

Sommario tecnico

1. Problema e Contesto

L'implementazione di algoritmi robotici su hardware reale presenta una sfida educativa significativa. Le aziende dedicano enormi sforzi ingegneristici per scrivere codice in linguaggi a basso livello (C/C++) per microcontrollori o computer embedded, un processo spesso incompatibile con i tempi e le risorse di un corso universitario.
Esiste un dilemma didattico tra tre approcci tradizionali, tutti con svantaggi:

1. Algoritmi semplificati: Implementati in C/C++ per funzionare sull'hardware, ma privi di complessità reale.
2. Infrastruttura sofisticata: Uso di framework avanzati (es. ROS 2, Drake) che astraggono troppo i dettagli, nascondendo la complessità dell'implementazione.
3. Simulazione non real-time: Uso di Python in ambienti simulati (es. Gazebo), che non prepara gli studenti alle sfide del tempo reale e dell'hardware vincolato.

L'obiettivo è colmare questo divario insegnando l'intera pipeline robotica (dinamica, stima dello stato, controllo, pianificazione) su una piattaforma hardware vincolata, mantenendo l'interesse per le discipline STEM.

2. Metodologia

Il corso è un progetto pratico da 9 ECTS (circa 270 ore) di livello magistrale, strutturato in quattro moduli principali. La caratteristica distintiva è l'uso del linguaggio di programmazione Rust sia per la simulazione su PC che per il deployment diretto su un microcontrollore STM32 (168 MHz, 192 kB di RAM) che pilota un drone quadricottero commerciale (Bitcraze Crazyflie 2.1).

Scelta di Rust

Il paper adotta Rust per i seguenti vantaggi tecnici:

• Gestione della memoria: Controllo completo simile a C/C++ ma con un "borrow checker" che garantisce la sicurezza a tempo di compilazione, eliminando errori comuni come buffer overflow.
• Supporto Embedded: A differenza di Python, Rust supporta nativamente architetture microcontrollori senza bisogno di runtime pesanti.
• Astrazione Matematica: Sintassi simile a C++ con generici e sovraccarico degli operatori, permettendo di scrivere equazioni matematiche tip-safe senza librerie esterne.

Struttura del Corso

Il corso è diviso in quattro fasi sequenziali, dove gli studenti devono implementare tutto da zero (senza librerie matematiche predefinite o simulatori "scatola nera"):

1. Simulazione (4 settimane):

   • Gli studenti scrivono un simulatore multirotore in Rust partendo da casi 1D e 2D fino al caso 3D completo.
   • Devono implementare una propria libreria matematica (inclusi quaternioni per le operazioni in SO(3)) per evitare allocazioni dinamiche (heap) necessarie per l'embedded.
   • Validazione rigorosa tramite traiettorie derivate matematicamente (flatness differenziale) e dati reali raccolti dal drone.

2. Controllo (4 settimane):

   • Implementazione di un controllore geometrico non lineare a stabilità esponenziale (simile a quello usato in stack di volo avanzati come PX4).
   • Gli studenti integrano il codice Rust nel firmware open-source STM32 (scritto in C) utilizzando strumenti di interoperabilità come bindgen.
   • La sfida principale è la transizione da simulazione a realtà (Sim-to-Real), dove piccoli errori di unità o di tipo causano crash immediati.

3. Stima dello Stato (3 settimane):

   • Implementazione di filtri per stimare posizione, orientamento e velocità usando sensori di bordo (giroscopi, accelerometri, flusso ottico).
   • Focus sull'EKF Moltiplicativo (MEKF) per gestire nativamente la varietà SO(3), evitando le singolarità degli angoli di Eulero.
   • Sfide tecniche: stabilità numerica e inversione di matrici 9x9 in tempo reale su hardware limitato. Vengono introdotte ottimizzazioni come aggiornamenti scalari e differenziazione simbolica.

4. Pianificazione del Movimento (3 settimane):

   • Sfruttamento della proprietà di flatness differenziale dei multirotori per pianificare traiettorie agili attraverso passaggi stretti.
   • Implementazione di un pianificatore basato su Programmi Quadratici (QP) risolti in tempo reale (pochi millisecondi) direttamente sul microcontrollore.

3. Risultati

Il corso è stato eseguito due volte (autunno 2024/25 e 2025/26) con 10 studenti per edizione.

• Carico di lavoro: La maggior parte degli studenti ha riferito un impegno di 6-9 ore a settimana, rientrando nelle aspettative per 9 ECTS, nonostante la necessità di imparare Rust da zero (la maggior parte aveva esperienza solo in C e Python).
• Valutazione: Il corso ha ricevuto un punteggio medio di 1.1 su 5 (dove 1 è eccellente).
• Feedback: Gli studenti hanno apprezzato l'aspetto pratico e l'apprendimento profondo ("una delle lezioni migliori finora"). Le critiche principali riguardavano la necessità di materiali più completi (es. script di riferimento) e la suddivisione degli assignment in deliverable più piccoli.
• Successo Tecnico: È stato dimostrato che è possibile implementare componenti non lineari avanzati di uno stack robotico moderno su un microcontrollore a risorse limitate utilizzando Rust, senza librerie matematiche esterne.

4. Contributi Chiave

1. Pipeline Robotica Completa su Embedded: Dimostrazione che è possibile insegnare e implementare l'intera stack (dalla dinamica alla pianificazione) su un microcontrollore STM32 in un singolo corso magistrale.
2. Adozione di Rust nell'Educazione Robotica: Validazione di Rust come linguaggio unico per simulazione e deployment embedded, eliminando la necessità di riscrivere codice (es. da Python a C) e garantendo sicurezza e efficienza.
3. Approccio "No Black-Box": Gli studenti costruiscono simulatori e librerie matematiche da zero, acquisendo una comprensione profonda delle sfide numeriche e delle operazioni fondamentali (es. integrazione su varietà).
4. Materiali Didattici Aperti: Il corso fornisce materiale didattico completo e open-source, fungendo da blueprint replicabile per altre università.

5. Significato e Impatto

Questo lavoro offre un modello educativo innovativo che supera i limiti dei corsi tradizionali.

• Formazione Pratica: Prepara gli studenti alle sfide reali dell'ingegneria robotica, dove l'efficienza computazionale e la sicurezza del codice sono critiche.
• Scalabilità: La metodologia dimostra che l'uso di Rust può essere integrato con successo anche in corsi di laurea triennale, non solo magistrale.
• Futuro: L'approccio riduce la dipendenza da infrastrutture software predefinite, permettendo agli studenti di comprendere e controllare ogni strato del sistema, dal calcolo matematico alla fisica del volo, su hardware reale.

In sintesi, il paper dimostra che è possibile combinare teoria avanzata, programmazione di sistemi embedded e robotica fisica in un'unica esperienza formativa coerente, utilizzando Rust come collante tecnologico per colmare il divario tra simulazione e mondo reale.