Mecanum-Antrieb-Simulator: Seitfahrt und Schlupf

Steuerung

Jede Steuerung spielt das ganze Manöver bei Eingabe neu ab — die Pfade folgen dem Schieber beim Ziehen. Es gibt nichts zu starten.

Das linke Panel ist der Boden. Gestrichelt ist das Manöver wie kommandiert, durchgezogen wo der Roboter wirklich fuhr, gepunktet wo seine eigenen Encoder ihn wähnen. Das rechte Panel sind die vier Radumfangsgeschwindigkeiten über der Zeit mit markierter Motordecke. Eine Spur flach auf dieser Linie ist ein Rad ohne Motorreserve; Schlupf zeigt sich stattdessen links als Lücke zwischen durchgezogener und gepunkteter Linie.

Theorie

Ein Mecanum-Rad kann Kraft nur entlang seiner Rollenachsen in den Boden bringen. In jede andere Richtung dreht die Rolle einfach, und nichts wird übertragen. Diese Achsen liegen 45° zum Rad — die Bodenkraft eines Rades ist also auf eine einzige Linie fixiert, kein Motormoment bewegt sie.

Vier dieser Linien, alternierende Hand, summieren sich zu allem. Schreibe Radumfangsgeschwindigkeit gegen Chassis-Drall ξ = (vx, vy, ω), und du erhältst eine Zeile je Rad:

vᵢ = vx + sᵢ·vy + (sᵢ·xᵢ − yᵢ)·ω        sᵢ = ±1, die Rollenhand

Staple die vier Zeilen in Matrix A, und der ganze Antrieb ist v = A·ξ. Drei Folgen, und das Labor existiert, um jede sichtbar zu machen:

Vier Gleichungen, drei Unbekannte. Ein starres Chassis mit greifenden Rädern kann keine beliebigen Umfangsgeschwindigkeiten erzeugen — die Extragleichung heißt immer FL + FR = RL + RR. Ihr Residuum ist ein gratis Schlupfdetektor allein aus Encodern. Er feuert bei asymmetrischem Schlupf — ein Rad in der Luft, eines auf nassem Fleck, eines in falscher Ecke — und ist völlig blind, wenn alle vier gemeinsam rutschen. Darum altert Mecanum-Odometrie leise.

Traktion kostet 1/√2. Die nutzbare Antriebskraft des Motors läuft in Rollrichtung, die echte Bodenkraft ist aber √2-mal so groß, zeigend entlang der Rollenachse — und Reibung deckelt den Gesamtvektor. Die Grenze je Rad ist also μN/√2, und die Beschleunigungsdecke des Roboters:

a_max = μ·g / √2

Bei μ = 0,85 sind das 5,9 m/s² gegen 8,3 m/s² desselben Roboters auf glatten Rädern. Die Masse kürzt sich beidseitig — Ballast ändert nichts, das Gegenteil eines Schieberoboters, wo Gewicht die ganze Strategie ist.

Diagonalen kosten ebenfalls 1/√2. Ein 45°-Befehl legt vx + vy auf zwei Räder und null auf die anderen beiden — das beschäftigte Paar sättigt, während der Roboter nur mit V_MAX / √2 fährt. Schnellere Motoren verschieben diese Decke; nichts entfernt sie.

Die volle Herleitung inklusive Odometrie-Inverse steht in Mecanum-Rad-Kinematik.

Algorithmus

Jeder 5-ms-Schritt, in dieser Reihenfolge. Die zwei Pose-Integrationen am Ende sind bewusst getrennt — diese Trennung ist die Odometrie-Lektion.

1. Stick lesen für diesen Manöverpunkt.
2. In Roboterbezug drehen, wenn feldorientiert: vx' = vx·cos θ + vy·sin θ, vy' = −vx·sin θ + vy·cos θ. Roboterorientiert überspringt das ganz.
3. Inverse Kinematik — v = A·ξ mit der Matrix, an die die Firmware glaubt, immer der korrekten. Ein falsch eingebautes Rad kann Firmware nicht wissen.
4. Begrenzen — Gesamtvektor am schlechtesten Rad skalieren oder jedes Rad einzeln klemmen.
5. Radverzug — jeder Umfang jagt sein Ziel mit 0,1 s Antwort erster Ordnung, denn ein Drehzahlkreis ist gut, nicht instantan.
6. Was die Räder verlangen — Kleinste-Quadrate-Vorwärtskinematik auf den Umfangsgeschwindigkeiten mit der Matrix des wirklich gebauten Roboters.
7. Kräfte lösen, die das Chassis angleichen würden, dann zwei Decken in Folge anwenden: die des Motors (es gab je nur so viel Moment) und die des Bodens (μN/√2 je Rad).
8. Was der Boden verweigert, dreht stattdessen die Felge. Dieser Überschuss beschleunigt das Rad von seiner Solldrehzahl weg — das ist Durchdrehen, und das einzige Schlupfsymptom, das ein Encoder je melden kann.
9. Wahrheit integrieren aus den wirklich aufgebrachten Kräften.
10. Odometrie integrieren aus den Umfangsgeschwindigkeiten durch die Firmware-Matrix — denn der Encoder boltet am Rad, nicht am Boden.

Nichts darin sucht Schlupf oder fügt ihn ein. Schlupf ist Schritt 7, der eine Kraft verweigert, und die Drift, die du siehst, ist Schritt 10, der es nie erfährt.

Geführte Experimente

Jedes isoliert eine einzige Variable. Führe sie der Reihe nach aus; sie bauen auf.

1. Das, wofür du Mecanum-Räder gekauft hast

Lade Ein Quadrat, das schließt. Der Roboter fährt einen Meter vor, einen Meter rechts, zurück und links und kommt 17 mm vom Start entfernt an, die Kursanzeige verlässt nie 0,0°. Schalte das Manöver auf Quadrat mit Drehen an den Ecken — dasselbe Quadrat, gefahren wie ein Differenzialantrieb-Roboter muss. Es schließt ebenfalls, auf 4 mm. Merke dir, dass beide hier gehen.

Was zu beobachten ist: Das Seitwärtsquadrat translatiert in zwei Achsen und verbraucht dabei gar keinen Kurs. Kein Differenzialantrieb kann das versuchen.

2. Den Boden wegnehmen

Ziehe Bodengrip von 0,85 auf 0,25, beim Seitwärtsquadrat bleibend. Dann dasselbe beim Drehquadrat.

Was zu beobachten ist: Beobachte den Kurs, nicht die Distanz. Beide Roboter rutschen, beide verfehlen zu Hause; der seitwärtsfahrende verfehlt bei exakt gehaltenem Startkurs, denn er hat nie eine Drehung kommandiert. Der drehende verliert seinen Kurs und fährt dann das nächste Bein in falscher Richtung — so wird aus kleinem Schlupf großer Fehler. Jede Drehung ist eine frische Chance, die Orientierung zu verlieren, und die holonome Basis nimmt sie schlicht nicht.

Distanzen in diesem Experiment wandern zwischen Läufen bei verschiedenen Einstellungen — die ehrliche Antwort statt Bug: Ein auf allen vier Rädern rutschender Roboter ist ein Stick-Slip-System und landet nie zweimal gleich. Der Kurs hat dieses Problem nicht.

3. Den Encodern beim Lügen zusehen

Lade Gleiches Quadrat, fettiger Boden und sieh auf die zwei Linien im linken Panel. Die gepunktete Odometrielinie fährt ein sauberes Quadrat; die durchgezogene nicht. Der Roboter endet 225 mm von zu Hause, während seine eigenen Encoder ihn 133 mm anderswo wähnen, nachdem 1,27 m Boden unter den Rädern durchliefen, ohne den Roboter zu bewegen.

Beobachte nun Encoder-Abweichung. Sie bleibt die ganze Zeit bei 0,000.

Was zu beobachten ist: Die gratis Restprüfung — FL + FR sollte auf jedem starren Chassis RL + RR gleichen — fängt ein rutschendes Rad und ist völlig blind für alle vier gemeinsam. Diese Blindheit ist exakt, warum Mecanum-Odometrie leise versagt. Baue eine IMU ein oder Messräder und traue den Antriebsencodern keine Position mehr zu.

4. Die √2-Decke

Lade Diagonalsprint. Stick-Tempo ist 0,60 m/s, Radspitze ebenso — das Kommando sollte machbar sein. Ist es nicht: Das Kommando klemmt 91 % des Laufs, der Roboter deckelt bei 0,424 m/s — also 0,60/√2 auf drei Nachkommastellen, exakt erreicht.

Was zu beobachten ist: Im rechten Panel liegen zwei Spuren flach auf null, zwei kleben an der Decke. Ein 45°-Befehl legt vx + vy auf zwei Räder und nichts auf die anderen beiden — das beschäftigte Paar sättigt bei V_MAX / √2. Erhöhe die Radspitze, und die Decke wandert mit — die 71 % ändern sich nie.

5. Skalieren gegen Klemmen

Schalte das Manöver auf Fahren mit Drehen, schiebe Stick-Drall auf 240 °/s und kippe Über der Grenze zwischen beiden Einstellungen. Der Pfad ändert die Form.

Was zu beobachten ist: Skalieren gibt Tempo auf jeder Achse auf und hält die Richtung. Klemmen hält die Vorwärtsgeschwindigkeit und verliert 27 % der Drehung — der Roboter dreht im Lauf 127° statt 92°, kurvt also anders als verlangt. Dann zurück zum Diagonalsprint und derselbe Schalter: Es passiert nichts, denn die Leerlaufräder waren schon innerhalb der Grenze. So überlebt dieser Bug das Testen.

6. Ein Rad falschherum einbauen

Lade Ein Rad falschherum eingebaut oder drücke W auf den Diagrammen. Am Code hat sich nichts geändert.

Was zu beobachten ist: Der Roboter tut nicht mehr annähernd Befohlenes, und diesmal feuert die Restanzeige — groß und stetig statt stoßweise. Beachte, welche Spalte exakte Zahlen hat und welche nicht: Mit einem Rad gegen die anderen drei rutscht der Roboter dauernd, seine Endpose ist chaotisch. Das Residuum ist die Zahl, die überlebt — exakt darum gehört sie auf eine Telemetriezeile. Das ist das eine Symptom, das du am echten Roboter ohne IMU und ohne externe Referenz lesen kannst. Sieh auch den gezeichneten Roboter an: Die Schraffur der gespiegelten Ecke zeigt falschherum, die vier Rollenlinien bilden kein X mehr.

7. Feldorientiert, in einem Tastendruck

Lade Feldorientiert mit Drehen und drücke O für roboterorientiert und erneut O für zurück.

Was zu beobachten ist: Roboterorientiert zeichnet ein Vorwärts-Stick bei Drehen eine Rosette: Der Roboter reist 2,34 m Pfad und endet 0,30 m vom Start — 13 % seiner Mühe kamen irgendwo an. Feldorientiert reist derselbe Stick 2,03 m und endet 2,03 m entfernt: eine kerzengerade Linie, 100 %, bei sich drehendem Aufbau entlang. Sechs Zeilen Trigonometrie trennen beide — der Unterschied zwischen fahrbarem und unfahrbarem Roboter.

Was du beobachten solltest

Alle sieben zusammen:

• Vorwärts ist gratis; seitwärts und diagonal nicht. Jedes Rad trägt voll zu Vorwärtsfahrt bei. Eine Diagonale nutzt die Hälfte.
• Zwei Wurzel-zwei-Strafen, aus denselben 45°. Tempo auf der Diagonale und Traktion in jede Richtung. Keine kaufbar mit größeren Motoren.
• Masse kürzt sich. Die Beschleunigungsdecke ist μg/√2 bei jedem Robotergewicht — das Gegenteil eines Schieberoboters.
• Holonom schlägt Differenzial bei schlechtem Boden, denn die Drehungen sind es, wo der Fehler herkommt.
• Odometrie ist der Preis. Kein Abstimmproblem, kein Besser-Encoder-Problem — das rutschende Rad ist, wie der Antrieb funktioniert.

Umsetzung auf Hardware

Das Labor lohnt die zwanzig Minuten vor allem für Experiment 6. Ein falschherum-Rad kostet hier nichts und auf der Werkbank einen halben Tag — und es ist der Fehler, den du am ehesten baust.

Quellcode

Der ganze Antrieb sind diese zwei Funktionen. Geometrie lebt an genau einer Stelle.

const float LX = 0.075f;      // half the wheelbase, m (wheel centre to wheel centre / 2)
const float LY = 0.085f;      // half the track, m
const float K  = LX + LY;
const float R  = 0.0485f;     // wheel radius, m
const float V_MAX = 0.60f;    // rim speed the motors can actually hold, m/s

// Inverse kinematics + saturation. vx forward, vy LEFT, omega counter-clockwise.
void driveMecanum(float vx, float vy, float omega) {
  float w[4] = {
    vx - vy - K * omega,      // front left
    vx + vy + K * omega,      // front right
    vx + vy - K * omega,      // rear left
    vx - vy + K * omega,      // rear right
  };

  float peak = 0;
  for (int i = 0; i < 4; i++) peak = max(peak, fabsf(w[i]));
  if (peak > V_MAX) {                    // SCALE, never clip
    float s = V_MAX / peak;
    for (int i = 0; i < 4; i++) w[i] *= s;
  }

  for (int i = 0; i < 4; i++) wheelLoop[i].target = w[i];   // hand to the velocity loops
}

// Forward kinematics for odometry, and the free diagnostic.
float updateOdometry(const float rim[4], float dt) {
  float vx    = ( rim[0] + rim[1] + rim[2] + rim[3]) * 0.25f;
  float vy    = (-rim[0] + rim[1] + rim[2] - rim[3]) * 0.25f;
  float omega = (-rim[0] + rim[1] - rim[2] + rim[3]) * 0.25f / K;

  theta += omega * dt;
  poseX += (vx * cosf(theta) - vy * sinf(theta)) * dt;
  poseY += (vx * sinf(theta) + vy * cosf(theta)) * dt;

  // Four equations, three unknowns. On any rigid, gripping chassis this is zero.
  // Large and steady => a wheel is in the wrong corner. Bursty => something slipped.
  return (rim[0] + rim[1]) - (rim[2] + rim[3]);
}

Die Herleitung dieser vier Zeilen und warum das Residuum funktioniert steht in Mecanum-Rad-Kinematik. wheelLoop[i].target bedeutungsvoll zu machen ist Drehzahlregelung im geschlossenen Kreis. Der Bau ist der Mecanum-Roboter.