Ein Alien als Vorbild

Wer Andy Weirs Roman Project Hail Mary gelesen hat, kennt Rocky – das wohl
liebenswürdigste Alien der jüngeren Science-Fiction. Rocky ist ein Eridianer:
ein etwa hundegroßes Wesen mit einem panzerartigen, gesteinsähnlichen Körper
(daher der Name), das fünffach radialsymmetrisch gebaut ist, auf mehreren Beinen
läuft, keine Augen besitzt, sondern seine Umgebung über Schall „sieht“, und sich
in Tonfolgen statt in Worten unterhält. Vor allem aber ist Rocky ein genialer
Ingenieur.

Genau diese fünffache Symmetrie war die Initialzündung für diesen Roboter:
Rocky MK1 ist ein 3D-gedruckter Laufroboter mit (in der Standardausführung)
fünf Beinen, die rund um einen runden Körper angeordnet sind – ein Pentapod,
der dem radialen Bauplan seines literarischen Namensgebers nachempfunden ist.
Angetrieben wird er von einem ESP32, gesteuert über eine FlySky-Fernsteuerung.

Was steckt drin? Die Hardware

Rocky ist bewusst aus gut verfügbaren Bauteilen aufgebaut:

• Gehirn: ein ESP32-Mikrocontroller. Er berechnet die komplette
  Bewegung, treibt die Servos an und liest die Fernsteuerung aus.
• Muskeln: 15 serielle Servos vom Typ ST3020 (3 pro Bein). Sie hängen
  alle an einem einzigen seriellen Bus (1 MBaud) und werden in einem Rutsch
  synchron mit neuen Zielpositionen versorgt.
• Skelett: vollständig 3D-gedruckt.
• Nerven: ein FlySky-Empfänger, der die Knüppel-, Poti- und
  Schalterstellungen der Fernbedienung über das IBUS-Protokoll an den ESP32
  schickt.
• Füße: jedes Bein hat optional einen Kontaktschalter an der Fußspitze,
  der erkennt, ob der Fuß den Boden berührt.

Jedes Bein besteht aus drei Segmenten mit je einem Servo:

Segment	Länge	Funktion
Coxa (Hüfte)	54 mm	schwenkt das Bein seitlich
Femur (Oberschenkel)	120 mm	hebt und senkt das Bein
Tibia (Unterschenkel/Knie)	222,5 mm	streckt und beugt das Knie

So weit, so klassisch. Das Interessante an Rocky steckt aber nicht in der
Hardware, sondern in der Software – genauer gesagt in der Bibliothek, die das
Laufen überhaupt erst möglich macht.

---

Das Gehirn: die MultiLegRobotWithIK-Library

Der Code von Rocky ist in zwei Teile getrennt:

1. Die Firmware (im Projekt Rocky_MK1) ist nur der „Klebstoff“: Sie liest
   die Fernsteuerung, ruft die Bibliothek auf und schiebt die Ergebnisse auf die
   Servos.
2. Die eigentliche Lauf- und Kinematik-Engine steckt in einer eigenen,
   wiederverwendbaren Bibliothek namens MultiLegRobotWithIK.

Diese Trennung ist Absicht: Die Bibliothek rechnet nur Winkel aus. Sie weiß
nichts von Servos, nichts von FlySky, nichts von der konkreten Verkabelung. Das
macht sie klein, hardwareunabhängig und auch für ganz andere Roboter nutzbar.

Vorwärts- vs. inverse Kinematik

Der naive Weg, einen Laufroboter zu programmieren, wäre: „Stelle Servo 1 auf
30°, Servo 2 auf 45°, Servo 3 auf 90°.“ Das nennt man Vorwärtskinematik –
und es ist die Hölle. Man müsste für jede Körperhöhe, jede Neigung und jeden
Schritt von Hand Winkel ausrechnen.

Rocky geht den umgekehrten Weg, die inverse Kinematik (IK): Man sagt nicht,
welche Winkel die Gelenke haben sollen, sondern wo der Fuß im Raum stehen soll. Die nötigen Gelenkwinkel rechnet die Bibliothek selbst aus – mit
Trigonometrie, im Kern dem Kosinussatz.

Der Vorteil: Solange der Fuß auf einer festen Stelle am Boden „geparkt“ ist,
bleibt er dort stehen – egal, ob der Körper sich hebt, senkt, neigt oder dreht.
Die Beine korrigieren ihre Winkel automatisch. Genau das lässt Rocky so flüssig
und „organisch“ wirken.

Wie die IK rechnet

Für jedes Bein läuft pro Schleifendurchlauf grob Folgendes ab:

1. Aus der Körperpose (Höhe, Neigung um zwei Achsen, Gier-Drehung) wird die
   Position der Hüfte im Raum berechnet.
2. Der Vektor von der Hüfte zum gewünschten Fußpunkt wird in das lokale Koordinatensystem des Beins projiziert – aufgeteilt in eine radiale
   Richtung (nach außen vom Körper weg) und eine tangentiale Richtung
   (seitlich).
3. Die Coxa schwenkt nur so weit, wie es nötig ist, um den seitlichen
   (tangentialen) Versatz auszugleichen.
4. Femur und Tibia werden dann als ebenes Zwei-Glieder-Armproblem mit dem
   Kosinussatz gelöst (das Knie beugt dabei nach außen).
5. Liegt der Zielpunkt außerhalb der Reichweite des Beins, meldet die IK die
   Position als ungültig zurück, statt unsinnige Winkel zu liefern.

Jedes Bein ist ein eigenes Objekt – und das ist der Clou

Der wichtigste Designentscheid der Bibliothek: Es gibt keine fest verdrahtete Annahme, dass die Beine gleichmäßig im Kreis verteilt sind. Beim Aufbau des
Roboters übergibt man ein Array aus RobotLeg-Objekten, und jedes Bein bekommt
seine eigenen Parameter:

RobotLeg(bodyRadius,    // Abstand Körpermitte → erstes Servo dieses Beins
         coxaLength,    // Länge der Hüfte
         thighLength,   // Länge des Oberschenkels (Femur)
         shinLength,    // Länge des Unterschenkels (Tibia)
         heightOffset,  // vertikaler Versatz dieser Hüfte
         baseFootExtend,// wie weit der Fuß nach außen steht
         baseAngleDeg); // wo das Bein rund um den Körper sitzt (Grad)

Weil jeder Teil der Engine – die IK, die Schrittplanung und die Sonderposen –
den Montagewinkel baseAngleDeg jedes Beins direkt ausliest (und sich nicht
auf eine i * 360° / N-Formel verlässt), funktionieren auch asymmetrische Aufbauten ganz ohne Sonderbehandlung:

• ein vierbeiniger Späher,
• ein klassischer Hexapod,
• ein perfekt symmetrischer Oktopod,
• oder bewusst schief: längere Vorderbeine, kürzere Hinterbeine, ungleiche
  Winkelabstände.

Für Rocky sitzen die fünf Beine schlicht im 72°-Raster (0°, 72°, 144°, 216°,
288°) – aber das ist eine Konfiguration in der definitions.h, keine in Stein
gemeißelte Mathematik.

Das Koordinatensystem

Die Bibliothek denkt in einem einfachen 3D-System: X/Z ist die Bodenebene, Y zeigt nach oben. Die Fußziele leben auf dem Boden; der Körper „schwebt“ um
Höhe + heightOffset über jeder Hüfte. Das macht die Steuerung intuitiv – „lauf
nach vorne“ heißt einfach, die Fußziele in Z zu verschieben.

Der Gang: eine Zustandsmaschine

Das Laufen selbst ist keine einmalige Rechnung, sondern eine kleine
Zustandsmaschine, die pro Schleifendurchlauf einen Takt weiterläuft. Sie kennt
drei Zustände:

• Walk_Idle – steht still, der Laufzyklus ist sauber bei Schritt 0
  eingefroren.
• Walk_Active – es kommt eine Laufeingabe, der Zyklus läuft.
• Walk_Stopping – der Knüppel wurde losgelassen, aber der aktuelle Zyklus
  wird noch sauber zu Ende gefahren, bevor wieder angehalten wird.

Dieser „sauber zu Ende fahren“-Mechanismus sorgt dafür, dass Rocky nie mitten im
Schritt einfriert, sondern immer in einer stabilen Pose zum Stehen kommt. Auch
neue Steuerbefehle werden nur an einem sauberen Zyklus-Nullpunkt übernommen –
die Fußziele ändern sich also nie mitten in einem Schritt.

Wie viele Beine heben gleichzeitig ab?

Hier wird die Bibliothek clever, weil sie sich an die Beinzahl anpasst:

• Bei 4 oder weniger Beinen hebt immer nur ein Bein gleichzeitig ab.
  Mehr würde den Roboter umkippen lassen. Die drei stehenden Beine bilden ein
  Stützdreieck.
• Bei 5 oder mehr Beinen hebt die Hälfte der Beine gleichzeitig ab
  (N / 2). Das ergibt einen schnelleren Gang, weil mehr Beine pro Zyklus neu
  gesetzt werden.

Welche Beine gerade „dran“ sind, rotiert dabei zyklisch durch alle Beine – mit
konstantem Abstand, damit das Muster gleichmäßig bleibt. Die Schub-Faktoren der
stehenden Beine sind so austariert, dass sich die seitlichen Bewegungen
gegenseitig aufheben: Der Körper wandert beim Laufen nicht zur Seite.

Schwerpunktverschiebung beim Vierbeiner

Ein Spezialfall, der viel Liebe gekostet hat: Wenn ein vierbeiniger Roboter
ein Bein anhebt, kippt er leicht in dessen Richtung. Deshalb kann die Bibliothek
den Körperschwerpunkt (in Rockys Fall sitzt der Akku in der Mitte)
kreisförmig zum jeweils gegenüberliegenden Bein verschieben. Damit wandert der
Schwerpunkt ins Stützdreieck der drei stehenden Beine – der Roboter bleibt
stabil. Bei fünf und mehr Beinen ist das nicht nötig und bleibt abgeschaltet.

Weiche Bewegungen statt Ruckeln

Damit die Beine nicht ruckartig von A nach B springen, interpoliert die
Bibliothek jeden Schritt über viele Zwischenschritte (in Rockys Fall 70 pro
Phase). Beine in der Luft folgen dabei einer Ease-In/Ease-Out-Kurve und
einem Sinus-Bogen in der Höhe – sie starten und landen also sanft und heben
sich in einem schönen Bogen. Beine am Boden bewegen sich linear, damit sie
nicht über den Untergrund schleifen. Genau dieses Detail war einer der größten
Sprünge in der gefühlten Qualität (siehe Versionsgeschichte unten).

Sonderposen: winken und grüßen

Neben dem Laufen kennt die Bibliothek Special Poses – choreografierte
Gesten. Dabei verlässt ein Beinpaar den normalen Laufzyklus, fährt in eine
vordefinierte Position, hält sie und kehrt anschließend automatisch in die
Standpose zurück. Auch das ist als eigene kleine Zustandsmaschine umgesetzt
(MovingInA → MovingInB → Holding → MovingOutA → MovingOutB). So kann Rocky zur
Begrüßung winken – ein netter Gruß an das gesprächige Alien, das ihn inspiriert
hat.

Gelenk-Limits: das jüngste Feature

Jedes Servo hat mechanische Grenzen. Werden sie überschritten, kann die Mechanik
blockieren oder Schaden nehmen. Die Bibliothek prüft deshalb für jedes Bein, ob
die berechneten Winkel innerhalb erlaubter Limits liegen – ist eine Pose
nicht erreichbar, wird die letzte gültige Stellung beibehalten.

Lange Zeit waren diese Limits fest im Bibliothekscode verdrahtet und damit
nur zu Rocky kompatibel. Seit Kurzem gibt es dafür zwei kleine Strukturen –
Limits (mit min und max) und LegLimits (je ein Limits für Coxa, Femur
und Tibia) –, sodass die Grenzen pro Roboter in der definitions.h
eingestellt werden. Rockys Werte (Schwenk ±65°, Heben ±130°, Knie ±140°) sind
dabei unverändert übernommen, andere Aufbauten können nun eigene Grenzen setzen.

Der Ablauf pro Schleifendurchlauf

Zusammengefasst ruft die Firmware die Engine in jeder Runde in dieser
Reihenfolge auf:

Schritt	Aufruf	Aufgabe
1	applyControls(...)	Laufrichtung, Fußabstand und Körperpose übernehmen (nur am Zyklus-Nullpunkt)
2	mainLoop()	Gang-Takt weiterstellen, abhebende Beine rotieren
3	prepareTargetPositions()	interpolierte Fußziele für diesen Teilschritt berechnen
4	specialPoseLoop()	Sonderposen-Zustandsmaschine takten
5	calculateAllLegAngles()	inverse Kinematik für alle Beine lösen

Danach übersetzt die Firmware die Winkel in Servo-Positionen und schreibt sie –
alle gleichzeitig – auf den Bus.

---

Wie Rocky entstanden ist — eine kleine Versionsgeschichte

Die Bibliothek ist nicht in einem Wurf entstanden, sondern über viele kleine
Schritte gewachsen. Die Commit-Historie erzählt die Geschichte recht schön:

1. Die ersten Lebenszeichen. Am Anfang stand schlicht die Eingabe: ein
Programmer, um den seriellen Servos IDs zuzuweisen, die Anbindung der
FlySky-Fernsteuerung und erste Sicherheitsfunktionen. Rocky konnte noch nicht
laufen – er konnte nur „hören“.

2. Erste Schritte – im Browser. Früh war Rocky sogar über einen
Webserver im Browser steuerbar. Es folgten die ersten Laufversuche
(„Better walking“) und die Möglichkeit, den Fußabstand per Fernsteuerung zu
ändern.

3. Der große Geometrie-Umbau. Mehrfach wurde die zugrunde liegende Geometrie
der inversen Kinematik neu aufgesetzt („new geometry“, „new files matching new
inverse kinematic geometry“). Hier wurde das mathematische Fundament gelegt, auf
dem alles Weitere steht.

4. Weg von „genau fünf Beinen“. Ein Schlüsselmoment: die Vorbereitung auf
4 bis 8 Beine statt nur fünf – inklusive Ideen wie einem „Skorpion-Modus“,
bei dem ein Fünfbeiner auf vier Beinen läuft. Hier begann der Wandel vom
festen Pentapod zur flexiblen Plattform.

5. Pflege, Komfort und ein Kopf. Es kam eine Transport-Stand-by-Pose, das
Drehen des ganzen Roboters auf der Stelle, eine ausgelagerte Kalibrierungsdatei,
ein Kopf mit LED-Ring samt Animationen – und der Wechsel auf das moderne
pioarduino-Toolchain. Der Webserver flog wieder raus, der Code wurde
aufgeräumt.

6. Richtig laufen lernen. Jetzt ging es um Laufqualität: zwei Beine
gleichzeitig in der Luft, optimiertes Timing, Easing der Beinbewegung und –
ein wichtiger Meilenstein – kein Schleifen mehr am Boden dank verbesserter
Animation. Außerdem kamen Lauf- und Strafing-Modus hinzu, sodass Rocky sich
wie ein Auto steuern lässt.

7. Persönlichkeit. Mit einer besseren Winke-Animation und schließlich
„New Special Poses“ bekam Rocky Gesten – die Grundlage für interaktives
Verhalten.

8. Die Architektur-Wende: ein Objekt pro Bein. Der vielleicht wichtigste
Refactor: „Class per Leg for better separation and support of more or less legs than 5“. Ab hier ist jedes Bein ein eigenständiges Objekt mit eigener
Geometrie. Das ist die Geburtsstunde der asymmetrischen Roboter als
vollwertiges Feature. Direkt darauf folgten der Höhenversatz pro Bein, der
Einbein-Gang für Vierbeiner und die Schwerpunktverschiebung für deren
Stabilität.

9. Aus Code wird eine Bibliothek. Schließlich der Schritt, der alles
zusammenführt: „This is now a library to include into your Robot Project via platformIO.“ Die Kinematik-Engine wurde aus dem Projekt herausgelöst und zur
eigenständigen, wiederverwendbaren Bibliothek MultiLegRobotWithIK. Rocky selbst
wurde zum eigenen Projekt, das die Bibliothek nur noch als verlinkte Abhängigkeit
einbindet.

10. Heute. Der jüngste Schritt sind die oben beschriebenen konfigurierbaren Gelenk-Limits – ein weiteres Stück, das von „nur für Rocky“ zu „für jeden
Mehrbeiner“ wandert.

Die rote Linie über all diese Commits hinweg: Aus einem ganz konkreten,
fünfbeinigen Roboter wurde Schritt für Schritt eine allgemeine Plattform für beliebige Mehrbeiner – ohne dass Rocky dabei je aufgehört hätte zu laufen.

---

Steuerung

Rocky hört auf eine FlySky-Fernsteuerung (10 Kanäle), die alles in Echtzeit
über IBUS überträgt:

• Rechter Knüppel: Laufrichtung und Geschwindigkeit (bzw. Lenkung, je nach
  Modus)
• Linker Knüppel: Körperneigung (Nicken und Rollen)
• Linkes Poti: Körperhöhe
• Rechtes Poti: Gier-Drehung des Körpers
• Schalter: Moduswechsel (Fahrzeug vs. Strafing), Sonderposen, Gesten

Ein Schalter wechselt zwischen zwei Steuerschemata:

• Fahrzeug-Modus: vorwärts/rückwärts + Lenken, wie bei einem Auto
• Strafing-Modus: volle Richtungskontrolle in alle Richtungen, wie bei einer
  Drohne

---

Technische Daten

Beine	konfigurierbar (Standardausführung: 5)
Servos pro Bein	3 (Coxa, Femur, Tibia)
Mikrocontroller	ESP32
Coxa-Länge	54 mm
Femur-Länge	120 mm (Standard, pro Bein einstellbar)
Tibia-Länge	222,5 mm (217 mm + 5,5 mm Gummifuß)
Körperradius	~104 mm (Mitte → Beinansatz)
Körperhöhe	170–285 mm
Max. Schrittweite	230 mm
Gelenk-Limits	Schwenk ±65°, Heben ±130°, Knie ±140°
Kommunikation	FlySky-Empfänger (IBUS)
Servo-Bus	seriell (SCServo / ST3020)
Hülle	3D-gedruckt
Kinematik	inverse Kinematik (Kosinussatz)
Sprache	C++ (Arduino-Framework)

---

Ausblick

Wie sein Vorbild soll Rocky mit der Zeit klüger werden. Auf der Liste stehen:

• Sensorik: ein IMU zum automatischen Ausbalancieren auf unebenem Boden,
  und die Fuß-Kontaktschalter in den Gang einfließen lassen, damit Rocky
  „fühlt“, wo der Boden ist.
• Reinforcement Learning: einen Gang per KI trainieren – erst in der
  Simulation (MuJoCo / PyBullet), dann auf die echte Hardware übertragen.
• Abstandssensor: ein nach vorn gerichteter ToF-Sensor zur
  Hinderniserkennung.

Bis dahin läuft, dreht und winkt Rocky – ein kleiner, gesteinsgrauer Gruß an das
Alien, das ihn inspiriert hat.

Die Software für Rocky findest du hier: Rocky MK1 und die Inverse Kinematik Library gibts hier.

---

Rocky ist ein privates Hobbyprojekt von Jeanette Müller.