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

Dit paper beschrijft een innovatieve mastercursus waarin studenten de volledige robotica-stack leren implementeren in Rust op een beperkte STM32-microcontroller, waardoor ze real-time vliegende robots kunnen bouwen zonder gebruik te maken van black-box software.

De kern

Stel je voor dat je een groep studenten de kunst leert om een drone te laten vliegen. Maar niet zomaar een drone die je koopt en op een knop drukt. Nee, deze studenten moeten de drone vanaf nul bouwen, van de wiskunde tot de code die erop draait. En het meest bijzondere: ze doen dit allemaal op een computerchip die zo klein en zwak is als die in een goedkope digitale horloge.

Dit is het verhaal van het vak "Rusty Flying Robots" van de Technische Universiteit Berlijn. Hier is hoe het werkt, vertaald in alledaagse taal:

1. Het Grote Dilemma: Te simpel of te moeilijk?

Normaal gesproken hebben universiteiten een lastige keuze als ze robotica willen leren:

• Optie A: Je leert simpele dingen op een simpele manier, maar het voelt niet echt als echte robotica.
• Optie B: Je gebruikt zware, ingewikkelde software die alles voor je regelt (zoals een "zwarte doos"), maar dan leer je niet hoe het werkt.
• Optie C: Je doet alles in een computersimulatie, maar dan heb je geen echte drone die door de lucht zoeft.

Deze docenten wilden alles tegelijk: de echte wiskunde, de echte code, en een drone die echt vliegt. Maar ze moesten het doen op een heel beperkt stukje hardware (een STM32-chip).

2. De Oplossing: De "Rust" Taal

Om dit mogelijk te maken, kozen ze voor een programmeertaal die Rust heet.

• C/C++ is als een oude, betrouwbare vrachtwagen: je kunt er alles mee doen, maar als je niet oplet, kun je je vingers klemmen (geheugenfouten).
• Python is als een comfortabele auto met automaat: makkelijk te besturen, maar hij is te traag en te zwaar voor de kleine chip.
• Rust is als een fietser met een superhelm. Hij is snel en licht (zoals C), maar de helm (de "borrow checker") zorgt dat je nooit je vingers klemt in de wielen. Het is veilig, maar ook razendsnel.

Het mooie is: je schrijft de code één keer in Rust, en die werkt zowel op je krachtige laptop (voor simulaties) als op de kleine drone-chip. Geen vertalen nodig!

3. De Reis in Vier Etappes

De studenten doorlopen vier stappen, alsof ze een drone bouwen in hun hoofd en dan in de lucht:

• Stap 1: De Zandbak (Simulatie)
  Voordat ze de echte drone aanraken, moeten ze zelf een virtuele drone bouwen in code. Ze mogen geen kant-en-klare simulators gebruiken. Ze moeten zelf bedenken hoe zwaartekracht werkt en hoe de propellers duwen. Het is alsof je eerst een auto moet tekenen en de motor moet ontwerpen voordat je mag rijden.
• Stap 2: De Piloot (Besturing)
  Nu moeten ze de "piloot" programmeren. Als de drone een beetje scheef hangt, moet de code direct weten hoe hij de motoren moet aansturen om recht te komen. Dit moet binnen een fractie van een seconde gebeuren, anders crasht de drone.
• Stap 3: Het Zenuwstelsel (Zinnes)
  De drone heeft geen ogen zoals wij. Hij heeft gyroscoops en versnellingsmeters. De studenten moeten code schrijven die al die ruwe data omzet in een duidelijk beeld: "Ik ben hier, ik vlieg naar boven, en ik draai naar links." Dit is lastig, want de wiskunde hierachter is best complex.
• Stap 4: De Routeplanner (Planning)
  Tenslotte moeten ze de drone leren om door smalle openingen te vliegen zonder te crashen. Ze moeten een route plannen die soepel is, alsof je een bal door een hindernisbaan gooit zonder dat hij stuitert.

4. Het Resultaat: Een Succesvol Experiment

De studenten (meestal derde- en vierdejaars) vonden het een uitdaging. Ze moesten een nieuwe taal leren (Rust) terwijl ze ook nog die zware wiskunde moesten begrijpen.

• De tijd: Het kostte ze gemiddeld 6 tot 9 uur per week.
• De mening: Ze vonden het fantastisch. Een student zei: "Dit was echt een van de beste colleges die ik ooit heb gehad."
• De uitdaging: Het was zwaar werk, maar het gevoel om te zien hoe hun code, die ze zelf hadden geschreven, een echte drone in de lucht hield, was onbetaalbaar.

Waarom is dit belangrijk?

Deze cursus bewijst dat je niet altijd de zwaarste, duurste computers nodig hebt om geavanceerde robotica te leren. Met de juiste taal (Rust) en de juiste aanpak (alles zelf bouwen in plaats van op "zwarte dozen" te vertrouwen), kunnen studenten leren hoe ze complexe systemen op kleine, goedkope apparaten kunnen laten werken.

Het is alsof je iemand leert vliegen door eerst de wind, de aerodynamica en de motor zelf te bouwen, in plaats van ze alleen te laten zitten in een vliegtuig dat al klaarstaat. En dat is precies wat deze studenten deden: ze bouwden hun eigen vlieger, en ze lieten hem vliegen.

Technische samenvatting

Probleemstelling

Het opleiden van studenten in robotica staat vaak voor een dilemma: hoe combineert men complexe, state-of-the-art algoritmen met de noodzaak van real-time uitvoering op beperkte hardware?

• Traditionele aanpakken vallen vaak in drie categorieën die elk tekortschieten:
  1. Simpele algoritmen in lage-niveau talen (zoals C) om hardware te laten werken, maar zonder geavanceerde theorie.
  2. Geavanceerde software-infrastructuur (zoals ROS 2 of Drake) die te veel engineering-tijd kost voor studentenprojecten.
  3. Simulaties in Python die niet real-time zijn en geen echte hardware-uitdagingen bieden.
• De uitdaging: Studenten moeten leren om niet-lineaire algoritmen (dynamica, schatting, besturing, planning) direct te implementeren op een microcontroller met beperkte rekenkracht (STM32), zonder gebruik te maken van "black-box" softwarebibliotheken die de onderliggende wiskunde verbergen.

Methodologie

De auteurs hebben een praktijkgerichte mastercursus (9 ECTS) ontwikkeld waarbij studenten een volledige robotica-pijplijn bouwen voor een multirotor-vliegtuig. De kern van de methode rust op twee didactische concepten:

1. Geen "Black-Box" Infrastructuur: Studenten bouwen hun eigen simulator, besturingsalgoritmen, toestandschatters en bewegingsplanners. Ze mogen geen bestaande mathematische bibliotheken of simulatieframeworks gebruiken.
2. Gebruik van Rust: De cursus gebruikt de programmeertaal Rust voor zowel de simulatie (PC) als de implementatie op de embedded hardware (STM32 microcontroller).

Cursusopbouw (4 fasen):

1. Simulatie (4 weken): Studenten schrijven een eigen multirotor-simulator in Rust. Ze beginnen met 1D en 2D gevallen en werken toe naar 3D dynamica in SE(3). Ze moeten hun eigen wiskundige bibliotheek bouwen (o.a. quaternions voor SO(3)) en de simulatie valideren met synthetische data en echte meetdata van de robot.
2. Besturing (4 weken): Implementatie van een niet-lineaire geometrische controller (gebaseerd op exponentiële stabiliteit, zoals in PX4). Studenten integreren deze C-code met Rust via bindgen en debuggen de overgang van simulatie naar de echte STM32-hardware (Bitcraze Crazyflie 2.1).
3. Toestandschatting (3 weken): Implementatie van een Multiplicative Extended Kalman Filter (MEKF) voor SO(3) om positie, oriëntatie en snelheid te schatten op basis van gyroscoop, versnelling en optische flow. Dit vereist zorgvuldige implementatie voor numerieke stabiliteit en real-time prestaties (inversie van 9x9 matrices).
4. Planning (3 weken): Bewegingsplanning voor agile manoeuvres door smalle doorgangen. Studenten gebruiken differentieel-vlaktheid (differential flatness) en kwadratische programmering (QP) om gladde trajecten te genereren die in real-time op de microcontroller kunnen worden opgelost.

Hardware: Een Bitcraze Crazyflie 2.1 quadrotor (ongeveer 35g) met optische flow-sensoren, aangedreven door een STM32 microcontroller (168 MHz, 192 kB RAM).

Belangrijkste Bijdragen

• Volledige Stack Implementatie: Een educatief raamwerk dat studenten dwingt om de volledige robotica-pijplijn (dynamica, schatting, besturing, planning) zelf te coderen, van wiskundige theorie tot embedded uitvoering.
• Rust voor Embedded Robotica: Het bewijs dat Rust een geschikte taal is voor zowel high-level simulatie als low-level embedded besturing. Rust biedt de prestaties van C/C++ met geheugenveiligheid (via de borrow checker) en ondersteuning voor generieke typen, wat ideaal is voor wiskundige vergelijkingen zonder runtime-overhead.
• Open Source Materiaal: Alle lesmateriaal, inclusief code voor simulatie en implementatie, is openbaar beschikbaar, waardoor de cursus reproduceerbaar is voor andere universiteiten.
• Overbrugging van de "Sim-to-Real" Gap: Door studenten hun eigen simulator te laten bouwen, ontstaat er een dieper begrip van de fysica en de foutenbronnen die optreden bij de overgang naar echte hardware.

Resultaten

De cursus werd twee jaar lang gegeven (herfst 24/25 en 25/26) met telkens 10 studenten.

• Leeruitkomsten: Studenten slaagden erin om state-of-the-art niet-lineaire componenten binnen de kaders van een 9-ECTS cursus te implementeren, ondanks dat de meeste geen voorkennis van Rust hadden.
• Tijdsinvestering: De gemiddelde tijdsinvestering lag binnen de verwachtingen voor een 9-ECTS vak (6-9 uur per week voor de helft van de studenten).
• Studentenfeedback: De cursus scoorde uitzonderlijk hoog (gemiddelde 1.1 op een schaal van 1-5, waarbij 1 het beste is). Studenten vonden het uitdagend maar leerzaam en "een van de beste cursussen".
• Uitdagingen: De grootste uitdaging was het leren van een nieuwe programmeertaal (Rust) en het debuggen van real-time crashes op de microcontroller door kleine fouten in de logica of eenheidconversies.

Betekenis en Impact

Dit paper toont aan dat het mogelijk is om geavanceerde robotica-onderwijs te geven zonder afhankelijk te zijn van zware, vooraf gedefinieerde software-ecosystemen.

• Educatieve Filosofie: Het benadrukt dat het zelf bouwen van simulators en wiskundige bibliotheken essentieel is voor een diepgaand begrip van robotica.
• Toekomstperspectief: Het succes van Rust in deze context suggereert dat de taal een sterke kandidaat is voor toekomstige embedded robotica-cursussen, zowel op bachelor- als master-niveau. Het biedt een blauwdruk voor het opleiden van ingenieurs die niet alleen theorie begrijpen, maar ook de praktische beperkingen van hardware kunnen overwinnen.