Arduino UNO Q mit leuchtender LED-Matrix und Qwiic-Kabel zum Modulino Movement während des Kugellabyrinth-Spiels

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.

Das Projekt in Kürze

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.
Das Kugellabyrinth in Aktion: Board neigen, Kugel balancieren – gerendert in Echtzeit vom STM32.

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

Mit * markierte Links sind Affiliate-Links, also Werbung. Kauft ihr darüber ein, erhalte ich eine Provision, der Preis bleibt für euch gleich. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Mehr dazu

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.

Arduino UNO Q mit angestecktem Qwiic-Kabel zum Modulino Movement, auf der Matrix läuft das Labyrinth
Mehr Verkabelung ist es nicht: Der Modulino Movement hängt am Qwiic-Kabel, auf der Matrix läuft bereits das erste Level.

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:

Arduino App Lab Dialog Create new app
Neue App in App Lab anlegen: das Plus neben „Apps“ öffnet den Dialog.
  • 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.

Arduino App Lab mit der laufenden Labyrinth-App und der eingebundenen Bibliothek Arduino_Modulino
Über das rot markierte Bibliotheks-Symbol kommt Arduino_Modulino in die App – danach taucht sie unter „Sketch Libraries“ auf und die App startet.

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 drei Labyrinth-Level des Kugelspiels auf der Arduino UNO Q LED-Matrix mit Start, Ziel, Wänden und Löchern
Die drei mitgelieferten Level: Grün = Start, Gelb = Ziel, Rot = Löcher, Grau = Wände.

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
Nahaufnahme der Arduino UNO Q LED-Matrix mit dem laufenden Kugellabyrinth
Nahaufnahme im Spiel: gedimmte Wände, helle Kugel – die acht Helligkeitsstufen machen das Level lesbar.

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
Rückseite des Modulino Movement mit aufgedrucktem Achsen-Diagramm
Praktisch für die Kalibrierung: Auf der Rückseite des Modulino ist das Achsen-Diagramm aufgedruckt.

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

Warum läuft das Spiel auf dem STM32 und nicht auf der Linux-Seite?

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.

Brauche ich zwingend den Modulino Movement?

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.

Läuft das Spiel auch auf dem Arduino UNO R4 WiFi?

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.

Wie baue ich eigene Level?

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.

Wie viel Strom braucht das Spiel?

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.

Ähnliche Beiträge