Arduino UNO Q Projekt: Kugellabyrinth bauen – ein Deep Dive in den Echtzeit-Chip
Zeit für das erste richtige Arduino UNO Q Projekt auf raspberry.tips – und wir steigen direkt mit einem Spiel ein: einem Kugellabyrinth auf der eingebauten LED-Matrix. Ihr neigt das Board, eine leuchtende Kugel rollt los, und ihr balanciert sie an pulsierenden Löchern vorbei durch drei Level bis ins Ziel. Klingt nach Spielerei? Ist es auch – aber nebenbei ist dieses Projekt der beste Deep Dive in den Teil des UNO Q, der in Tests meist zu kurz kommt: den Echtzeit-Mikrocontroller STM32U585. Genau der macht nämlich den Unterschied zwischen einer Kugel, die sich butterweich steuern lässt, und einer, die ruckelt.
Ein neigungsgesteuertes Kugellabyrinth mit drei Leveln auf der 8×13-LED-Matrix des Arduino UNO Q. Die Neigung liefert ein Modulino Movement (6-Achsen-IMU, ca. 13 €) am Qwiic-Port, die komplette Spiellogik läuft in Echtzeit auf dem STM32U585 – ganz ohne die Linux-Seite. Aufwand: rund 30 Minuten, kein Löten, der komplette Code liegt auf GitHub.
Warum ein Kugelspiel der perfekte Test für den Echtzeit-Chip ist
Der UNO Q hat bekanntlich zwei Gehirne: Der Qualcomm-Prozessor führt Debian Linux aus, der STM32U585 (Arm Cortex-M33, bis 160 MHz, 2 MB Flash, 786 kB SRAM) kümmert sich unter Zephyr OS um die Elektronik – Pins, Sensoren, die LED-Matrix. „Echtzeit“ heißt dabei nicht „besonders schnell“, sondern „garantiert pünktlich“: Der Mikrocontroller arbeitet eine Schleife stur im Takt ab. Zephyr ist ein schlankes Echtzeit-Betriebssystem: Anders als Linux schiebt es den Sketch nicht einfach beiseite, weil gerade etwas Wichtigeres ansteht.
Für unser Spiel bedeutet das: Die Schleife läuft mit rund 50 Ticks pro Sekunde. In jedem Tick wird der Beschleunigungssensor ausgelesen, die Kugelphysik gerechnet und die Matrix neu gezeichnet, danach wartet der Sketch 20 Millisekunden. Weil Sensorabfrage und Zeichnen jedes Mal fast gleich lange dauern, bleibt der Abstand zwischen zwei Ticks praktisch konstant. Auf einem Linux-System (egal ob auf der Linux-Seite des UNO Q oder einem Raspberry Pi) gibt es diese Garantie aus dem Userspace heraus nicht: Meistens klappt es, aber sobald das System beschäftigt ist, kommen einzelne Durchläufe zu spät – die Kugel springt, die Steuerung fühlt sich schwammig an. Bei einem Spiel ist das ärgerlich, bei einer Motorsteuerung oder einem Regelkreis ein echtes Problem. Genau diese Arbeitsteilung – Linux für die dicken Brocken, Mikrocontroller für alles Zeitkritische – ist die Kernidee des UNO Q.
Und das Beste: Die Linux-Seite bleibt dabei komplett frei. Während der STM32 das Spiel rechnet, könnte der Qualcomm-Prozessor parallel ein Kamerabild auswerten oder einen Webserver bedienen – dazu später mehr.
Die Hardware: UNO Q und Modulino Movement
- ein Arduino UNO Q – die Ersteinrichtung zeigt unsere Anleitung Arduino UNO Q einrichten
- ein Arduino Modulino Movement* (6-Achsen-IMU mit LSM6DSOX, ca. 13 €) – wer noch kein Board hat, bekommt beides zusammen im UNO-Q-4GB-Bundle mit Modulino Movement*
- das Qwiic-Kabel aus der Modulino-Packung – einstecken, fertig, gelötet wird nichts
Der Modulino kommt an den weißen Qwiic-Port an der Board-Kante (in unserer interaktiven Board-Übersicht ist das Punkt 12). Der Port hängt am I²C-Bus Wire1 und arbeitet mit 3,3 V – beides Details, die gleich im Code wichtig werden. Legt den Modulino flach neben oder hinter das Board, mit einem Klebepad gern direkt darauf: Er misst die Neigung, also sollte er sich mit dem Board bewegen.

App anlegen und Bibliotheken einrichten
Im Arduino App Lab legt ihr über das Plus neben „Apps“ eine neue App an. Den kompletten Code müsst ihr nicht abtippen – er liegt in unserem GitHub-Repository zur UNO-Q-Serie im Ordner labyrinth. Zwei Dateien der App werden ersetzt:
sketch/sketch.ino→ Inhalt durch sketch.ino ersetzen- die Bibliothek
Arduino_Modulinoüber den Button Add Sketch Library hinzufügen (siehe unten)
Der zweite Punkt ist der, über den ihr sonst garantiert stolpert: Ohne die Bibliothek bricht der Build mit fatal error: Arduino_Modulino.h: No such file or directory ab. Die sketch.yaml der App lässt sich in App Lab (Stand 0.10.0) nicht direkt bearbeiten – klickt stattdessen in der linken Seitenleiste auf das Bibliotheks-Symbol („Add Sketch Library“), sucht nach Arduino_Modulino und fügt sie hinzu. App Lab trägt sie damit selbst ins Build-Profil ein – die sketch.yaml der App sieht danach so aus:
profiles:
default:
platforms:
- platform: arduino:zephyr
libraries:
- Arduino_Modulino (0.9.0)
- STM32duino VL53L4CD (1.0.5)
- STM32duino VL53L4ED (1.0.1)
- Arduino_LSM6DSOX (1.1.2)
- Arduino_LPS22HB (1.0.2)
- Arduino_HS300x (1.0.0)
- ArduinoGraphics (1.1.5)
- Arduino_LTR381RGB (1.0.0)
default_profile: default
Danach auf Run klicken – der erste Build lädt die Bibliotheken herunter und dauert entsprechend etwas länger. Für das Spiel selbst arbeitet übrigens nur die Arduino_LSM6DSOX (der Treiber für den IMU im Modulino); der Rest ist Abhängigkeits-Ballast der Modulino-Familie.

So funktioniert das Spiel
Die Level: acht Zeilen Text
Jedes Level ist im Sketch nichts weiter als acht Textzeilen mit 13 Zeichen – eine pro Matrix-Zeile: # ist eine Wand, O ein Loch, S der Start, G das Ziel und . freie Bahn.
{
"S...#........",
"..O.#..O.#...",
"....#....#.O.",
".#..#.##.#...",
".#....#..#...",
".#.O..#..#.O.",
".#....#......",
"....O.#....G.",
},
Die Physik: 50-mal pro Sekunde, Tick für Tick
Das Herzstück ist die Spielschleife auf dem STM32. Pro Tick liest sie die Beschleunigung vom Modulino, verrechnet sie mit Reibung und bewegt die Kugel – mit Positionswerten zwischen den LED-Zellen, damit die Bewegung geschmeidig wirkt:
movement.update();
float ax = movement.getX(); // Neigung in g
float ay = movement.getY();
vx = (vx + ax * ACCEL) * FRICTION; // beschleunigen + Reibung
vy = (vy + ay * ACCEL) * FRICTION;
float nx = px + vx; // Wand im Weg? Dann abprallen
if (isWall((int)(nx + 0.5f), (int)(py + 0.5f))) { vx = -vx * 0.3f; }
else { px = nx; }
Rollt die Kugel auf ein Loch, blinkt sie dreimal und startet am Anfang; erreicht sie das Ziel, läuft eine Gewinn-Welle über die Matrix und das nächste Level lädt. Das komplette Spiel – Physik, Kollision, Animationen, drei Level – sind rund 200 Zeilen Code, und der 160-MHz-Cortex-M33 langweilt sich dabei: Die eigentliche Rechenlast liegt weit unter einem Prozent dessen, was der Chip könnte.
Die Anzeige: acht Helligkeitsstufen statt an/aus
Ein Detail, das kaum jemand über die UNO-Q-Matrix weiß: Sie kann nicht nur an/aus, sondern acht Helligkeitsstufen pro LED. Mit matrix.setGrayscaleBits(3) schalten wir den Modus frei und geben jedem Spielelement eine eigene Helligkeit – so bleibt auf einem einfarbigen Display trotzdem alles unterscheidbar:
- Wände: gedimmt, dauerhaft an
- Löcher: pulsieren ganz schwach – gut sichtbar, aber klar „gefährlich“
- Ziel: pulsiert hell
- Kugel: volle Helligkeit

Kalibrierung: Wenn die Kugel falsch rollt
Je nachdem, wie der Modulino neben dem Board liegt, können die Achsen vertauscht oder gespiegelt sein. Dafür gibt es drei Konstanten am Anfang des Sketches – bei unserem Aufbau war INVERT_X = -1 nötig, damit links auch links ist:
const bool SWAP_AXES = false; // true: links/rechts und vor/zurück vertauscht
const int INVERT_X = -1; // Vorzeichen der Links/Rechts-Achse
const int INVERT_Y = 1; // Vorzeichen der Vor/Zurück-Achse
Baut eure eigenen Level
Das Schönste am Text-Level-Format: Eigene Labyrinthe sind eine Sache von zwei Minuten. Kopiert einen der drei Level-Blöcke im Sketch, malt mit #, O und . euer eigenes Layout (8 Zeilen à 13 Zeichen, genau ein S und ein G) und ladet die App neu. Zwei Tipps aus der Praxis: Lasst Korridore mindestens eine Zelle breit – und spielt jedes Level einmal im Kopf durch, bevor ihr es der Kugel zumutet. Unser drittes Level hatte in der ersten Version einen Weg, der nur durch ein Loch führte – solche Sackgassen merkt man erst beim Nachverfolgen des Pfads.
Ausblick: Die Linux-Seite spielt noch gar nicht mit
Das Spiel nutzt bisher ausschließlich den Mikrocontroller – die Debian-Seite des UNO Q liegt brach. Genau da wird es für einen zweiten Teil spannend: Über die Bridge zwischen beiden Welten könnte der Sketch jeden Levelabschluss an ein Python-Skript melden, das daraus eine Highscore-Webseite baut – Echtzeit-Spiel auf dem M33, Weboberfläche auf dem Qualcomm, beides auf einem Board. Wenn euch das interessiert, schreibt es in die Kommentare. Alle bisherigen Artikel der Serie findet ihr in der Arduino-Kategorie, den kompletten Code im GitHub-Repository. Viel Spaß beim Balancieren!
Häufige Fragen zum Projekt
Weil der Mikrocontroller verlässlich im Takt arbeitet: Die Spielschleife läuft rund 50-mal pro Sekunde mit gleichmäßigem Abstand, und kein Linux-Scheduler funkt dazwischen. Unter Linux gäbe es diese Garantie nicht – unter Last kommen einzelne Durchläufe zu spät und die Steuerung wirkt schwammig. Genau diese Arbeitsteilung ist die Kernidee des Arduino UNO Q.
Für den Sketch aus dem Artikel ja – er nutzt die Arduino_Modulino-Bibliothek und deren LSM6DSOX-Treiber. Mit einem anderen I²C-Beschleunigungssensor am Qwiic-Port (3,3 V!) funktioniert das Prinzip genauso, ihr müsst aber die Sensor-Abfrage im Code auf dessen Bibliothek umstellen.
Nicht eins zu eins. Der UNO R4 WiFi hat eine 12×8-Matrix mit anderer Ansteuerung und keinen Qwiic-Port mit Wire1-Belegung wie der UNO Q. Die Spiellogik ließe sich portieren, Level-Format und Matrix-Rendering müssten aber angepasst werden.
Im Sketch ist jedes Level ein Block aus acht Textzeilen mit je 13 Zeichen: # für Wände, O für Löcher, S für den Start, G für das Ziel. Block kopieren, Layout ändern, App neu laden – und vorher den Weg einmal im Kopf durchspielen, damit kein Pfad durch ein Loch führt.
Kaum messbar mehr als das Board im Leerlauf – in unserem Test lag der UNO Q gesamt bei rund 0,4 W im Leerlauf und 1,4 W unter Volllast. Die Spiellogik lastet den 160-MHz-Mikrocontroller nicht einmal ansatzweise aus.



