Simulatore mecanum: traslazione, slittamento e deriva

Controlli

Ogni controllo riapre l’intera manovra quando riceve un input, quindi i percorsi seguono il cursore mentre lo trascini. Non c’è nulla da avviare.

Il pannello sinistro è il pavimento. La linea tratteggiata è la manovra come comandata, quella continua è dove il robot è realmente andato e quella punteggiata è dove i suoi encoder credono che sia andato. Il pannello destro mostra le quattro velocità al mozzo delle ruote nel tempo, con il limite del motore evidenziato. Una traccia piatta su quella linea è una ruota che ha esaurito la spinta del motore; lo slittamento compare invece nel pannello sinistro, come distanza tra la linea continua e quella punteggiata.

Teoria

Una ruota mecanum può esercitare forza sul pavimento solo lungo gli assi dei rulli. In ogni altra direzione il rullo semplicemente gira e non viene trasmessa forza. Questi assi sono inclinati di 45° rispetto alla ruota, quindi la forza al suolo di una ruota è vincolata a una singola retta del pavimento e nessuna quantità di coppia motore la sposta.

Quattro di queste rette, a mano alternata, possono sommarsi a qualsiasi cosa. Scrivi la velocità al mozzo rispetto alla torsione del telaio ξ = (vx, vy, ω) e ottieni una riga per ruota:

vᵢ = vx + sᵢ·vy + (sᵢ·xᵢ − yᵢ)·ω        sᵢ = ±1, the roller hand

Impila le quattro righe in una matrice A e l’intera trazione è v = A·ξ. Ne seguono tre conseguenze, ed esiste il laboratorio per rendere visibile ciascuna:

Quattro equazioni, tre incognite. Un telaio rigido con tutte le ruote in presa non può produrre velocità al mozzo arbitrarie — l’equazione in più dice sempre FL + FR = RL + RR. Il residuo di questo controllo è un rilevatore di slittamento gratuito calcolabile dai soli encoder. Scatta con uno slittamento asimmetrico — una ruota sollevata, una ruota su una zona bagnata, una ruota nell’angolo sbagliato — ed è completamente cieco quando tutte e quattro slittano insieme, ed è per questo che l’odometria mecanum peggiora in silenzio.

La trazione costa 1/√2. La forza utile del motore decorre lungo la direzione di rotolamento, ma la forza al suolo reale è √2 volte quella, diretta lungo l’asse del rullo — e l’attrito limita l’intero vettore. Quindi il limite per ruota è μN/√2 e il limite di accelerazione del robot è:

a_max = μ·g / √2

Con μ = 0.85 sono 5.9 m/s² contro 8.3 m/s² per lo stesso robot con ruote normali. La massa si cancella da entrambe, quindi il zavorro non cambia nulla — l’opposto di un robot che spinge, dove il peso è l’intera strategia.

Anche le diagonali costano 1/√2. Un comando a 45° mette vx + vy su due ruote e zero sulle altre due, quindi la coppia impegnata satura mentre il robot si muove solo a V_MAX / √2. Motori più veloci spostano quel limite; nulla lo elimina.

La derivazione completa, compresa l’inverso dell’odometria, è in cinematica delle ruote mecanum.

Algoritmo

Ogni passo di 5 ms, in quest’ordine. Le due integrazioni della posa alla fine sono deliberatamente separate — quella separazione è la lezione sull’odometria.

1. Leggi il comando per questo punto della manovra.
2. Ruota nel sistema del robot se è orientato al campo: vx' = vx·cos θ + vy·sin θ, vy' = −vx·sin θ + vy·cos θ. Se è orientato al robot, salta questa operazione.
3. Cinematica inversa — v = A·ξ, usando la matrice in cui crede il firmware, che è sempre quella corretta. Una ruota montata male non è qualcosa che il firmware possa conoscere.
4. Limita — ridimensiona l’intero vettore in base alla ruota peggiore oppure limita ogni ruota separatamente.
5. Ritardo delle ruote — ogni mozzo insegue il proprio obiettivo con una risposta del primo ordine di 0.1 s, perché un anello di velocità è valido, non istantaneo.
6. Ciò che le ruote richiedono — cinematica diretta ai minimi quadrati sulle velocità al mozzo, usando la matrice del robot realmente costruito.
7. Risolvi le forze che farebbero corrispondere il telaio, poi applica due limiti in ordine: quello del motore (c’era solo una quantità limitata di coppia) e quello del pavimento (μN/√2 per ruota).
8. Tutto ciò che il pavimento rifiuta fa girare il mozzo. Quell’eccedenza accelera la ruota rispetto alla velocità comandata, ed è la rotazione libera della ruota: l’unico sintomo di slittamento che un encoder può mai segnalare.
9. Integra la verità dalle forze effettivamente applicate.
10. Integra l’odometria dalle velocità al mozzo, attraverso la matrice del firmware — perché l’encoder è fissato alla ruota, non al pavimento.

Niente in questa sequenza cerca lo slittamento o lo inserisce. Lo slittamento è il passo 7 che rifiuta una forza, e la deriva che vedi è il passo 10 che non lo scopre mai.

Esperimenti guidati

Ognuno isola una sola variabile. Esegui in ordine; si costruiscono.

1. La cosa per cui hai comprato le ruote mecanum

Carica Un quadrato che si chiude. Il robot avanza un metro, gira a destra di un metro, torna indietro e a sinistra, poi rientra a 17 mm da dove è partito con l’indicazione dell’orientamento sempre ferma a 0.0°. Ora passa la manovra a quadrato, con inversioni agli angoli — lo stesso quadrato, guidato come deve fare un robot a trazione differenziale. Si chiude anche questo, a 4 mm. Ricorda che qui funzionano entrambe le soluzioni.

Cosa osservare: il quadrato in traslazione si sposta su due assi e consuma niente orientamento per farlo. Nessuna trazione differenziale può tentare la stessa cosa.

2. Togli il pavimento

Trascina l’attrito del pavimento da 0.85 a 0.25, mantenendo il quadrato in traslazione. Poi fai lo stesso con il quadrato con inversioni.

Cosa osservare: guarda l’orientamento, non la distanza. Entrambi i robot scivolano e mancano entrambi casa; quello in traslazione manca mentre punta ancora esattamente dove è partito, perché non ha mai comandato una rotazione. Quello con inversioni perde l’orientamento e poi percorre il tratto successivo nella direzione sbagliata: è così che un piccolo slittamento diventa un grande errore. Ogni rotazione è una nuova occasione di perdere il tracciato, e la base olonomica semplicemente non le accetta.

Le distanze in questo esperimento cambiano tra un’esecuzione e l’altra con impostazioni diverse, ed è la risposta onesta anziché un errore: un robot che scivola su tutte e quattro le ruote è un sistema stick-slip e non si ferma due volte nello stesso punto. L’orientamento non ha questo problema.

3. Guarda gli encoder mentire

Carica Stesso quadrato, pavimento untuoso e guarda le due linee nel pannello sinistro. La linea punteggiata dell’odometria disegna un quadrato ordinato; quella continua no. Il robot finisce a 225 mm da casa mentre i suoi encoder lo collocano 133 mm altrove, dopo che 1.27 m di terreno sono passati sotto le ruote senza muovere affatto il robot.

Ora guarda l’indicatore Discordanza tra encoder. Resta a 0.000 per tutto il tempo.

Cosa osservare: il controllo residuo gratuito — FL + FR dovrebbe essere uguale a RL + RR su qualsiasi telaio rigido — intercetta una ruota che scivola ed è completamente cieco a quattro ruote che scivolano insieme. Questa cecità è esattamente il motivo per cui l’odometria mecanum fallisce in silenzio. Monta un IMU oppure ruote passive e smetti di fidarti degli encoder della trazione per la posizione.

4. Il limite √2

Carica Corsa diagonale. La velocità del comando è 0.60 m/s e così anche la velocità massima della ruota, quindi il comando dovrebbe essere realizzabile. Non lo è: il comando viene limitato per il 91% dell’esecuzione e il robot raggiunge al massimo 0.424 m/s — che è 0.60/√2 a tre decimali, raggiunto esattamente.

Cosa osservare: nel pannello destro, due tracciati restano piatti a zero mentre due sono bloccati al limite. Un comando a 45° mette vx + vy su due ruote e niente sulle altre due, quindi la coppia impegnata satura a V_MAX / √2. Aumenta la velocità massima della ruota e il limite si sposta con essa — il 71% non cambia mai.

5. Ridimensionare o limitare

Passa la manovra a guida con rotazione, spingi la rotazione del comando a 240 °/s e cambia Oltre il limite tra le due impostazioni. Il percorso cambia forma.

Cosa osservare: il ridimensionamento rinuncia alla velocità su ogni asse e conserva la direzione. Il limite per singola ruota conserva la velocità in avanti e perde il 27% della rotazione — il robot compie 127° durante l’esecuzione invece di 92° — quindi si curva diversamente da come gli è stato chiesto. Poi torna alla corsa diagonale e prova lo stesso interruttore: non succede nulla, perché le ruote inattive erano già dentro il limite. Ecco come questo errore sopravvive ai test.

6. Monta una ruota al contrario

Carica Una ruota montata al contrario, oppure premi W sui grafici. Nulla nel codice è cambiato.

Cosa osservare: il robot non sta più facendo niente di simile a ciò che gli è stato detto e questa volta l’indicatore del residuo scatta — grande e stabile anziché a raffica. Nota quale colonna ha numeri esatti e quale no: con una ruota che combatte le altre tre il robot scivola continuamente, quindi la sua posa finale è caotica. Il residuo è il numero che sopravvive, ed è esattamente il motivo per cui vale la pena metterlo su una linea di telemetria. È l’unico sintomo che puoi leggere su un robot reale senza IMU e senza riferimento esterno. Guarda anche il robot disegnato: la tratteggiatura dell’angolo specchiato punta nella direzione sbagliata e le quattro linee dei rulli non formano più una X.

7. Orientato al campo, con un tasto

Carica Orientato al campo con rotazione, poi premi O per tornare all’orientamento al robot e O di nuovo per rientrare.

Cosa osservare: nell’orientamento al robot, un comando avanti mantenuto premuto durante la rotazione disegna un tracciato a rosetta: il robot percorre 2.34 m di percorso e finisce a 0.30 m da dove è partito — il 13% del suo sforzo è andato chissà dove. Nell’orientamento al campo, lo stesso comando percorre 2.03 m e finisce a 2.03 m di distanza: una retta perfetta, 100%, con il corpo che ruota per tutta la lunghezza. Sei righe di trigonometria separano i due casi, ed è la differenza tra un robot guidabile da una persona e uno che nessuno può guidare.

Cosa osservare

Riunendo i sette punti:

• L’avanti è gratis; il laterale e il diagonale no. Ogni ruota contribuisce pienamente al movimento in avanti. Una diagonale ne usa metà.
• Due penalità della radice di due, dallo stesso 45°. Velocità su una diagonale e trazione in ogni direzione. Nessuna delle due si compra con motori più grandi.
• La massa si cancella. Il limite di accelerazione è μg/√2 qualunque sia il peso del robot, l’opposto di un robot che spinge.
• La trazione olonomica batte quella differenziale quando il pavimento è cattivo, perché le rotazioni sono la fonte dell’errore.
• L’odometria è il prezzo. Non è un problema di regolazione né di encoder migliori — il fatto che la ruota scivola è il modo in cui la trazione funziona.

Portarlo sull’hardware

Il laboratorio vale i suoi venti minuti soprattutto per l’esperimento 6. Montare una ruota al contrario non costa nulla qui e mezza giornata sul banco, ed è il guasto che hai più probabilità di costruire.

Codice sorgente

L’intera trazione è questa coppia di funzioni. La geometria vive in un unico punto.

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]);
}

La derivazione di quelle quattro righe, e il motivo per cui il residuo funziona, è in cinematica delle ruote mecanum. Dare un significato a wheelLoop[i].target è il controllo a ciclo chiuso della velocità delle ruote. Costruire il dispositivo è il robot mecanum omnidirezionale.