Bouw een Mecanum-robot die zijwaarts rijdt

Wat je bouwt

Een vierwielerrobot die op de vloer elke richting op kan zonder eerst te draaien en kan draaien zonder te veranderen waar hij heen gaat. Duw hem zijwaarts door een gang waarin hij net past; houd een camera op iets gericht terwijl je om dat punt heen beweegt; corrigeer 3 cm van een lijn door 3 cm te stappen, in plaats van een boog uit te rijden en weer terug.

Dit is de eerste robot op deze site met drie onafhankelijk regelbare snelheden in plaats van twee. Het is ook de eerste waarvan de aandrijving werkelijk moeilijker is dan de sensoren, en daarom bestaat vrijwel de hele bouw uit motoren, encoders en regellussen.

De acceptatietest is bewust bot: rij een vierkant van 1 m zijwaarts af en kom binnen 5 cm terug met dezelfde koers. Geen enkele robot met differentiële aandrijving kan die test zelfs maar proberen.

Het getal dat dit project bepaalt

Alles in deze bouw komt terug op één constante:

k = lx + ly

waar lx de halve wielbasis is (van vooras tot achteras, gehalveerd) en ly de halve spoorbreedte (van linker- tot rechterwielen, gehalveerd). In de referentieopbouw zijn dat 75 mm en 85 mm, dus k = 0,160 m.

Dat ene getal koppelt rotatie aan de wielen. Is het verkeerd, dan rijdt de robot nog steeds — maar een zuivere spinopdracht kruipt over de vloer en een zuivere zijwaartse beweging maakt een bocht, omdat rotatie en translatie in elkaar overlopen. Meet van wielmiddelpunt tot wielmiddelpunt, niet vanaf de chassisplaat; die is meestal breder dan je denkt.

De andere getallen die je voor de start met marker op het chassis wilt schrijven:

Stuklijst

£90–170 in totaal. De wielen en het viervoudige aantal motoren zijn de reden dat een £50-robot met twee wielen hier uiteindelijk deze robot wordt.

Hoe alles samenhangt

        2S LiPo ──┬── 470 µF ── TB6612FNG #1 ── FL motor ── FL encoder ─┐
                  │                         └── FR motor ── FR encoder ─┤
                  ├── 470 µF ── TB6612FNG #2 ── RL motor ── RL encoder ─┼── ESP32
                  │                         └── RR motor ── RR encoder ─┘   (4 PWM,
                  └── 5 V BEC ──────────────────────────────── ESP32 ──────  8 GPIO,
                                                                   │         I²C)
                                                   MPU6050 ── I²C ─┘

Drie bedradingskeuzes zijn niet voor de hand liggend:

• De ESP32 krijgt zijn eigen spanningsregelaar. Vier motoren die tegelijk starten laten het pakket hard inzakken, waardoor een besturingseenheid op dezelfde baan brown-out krijgt en tijdens een commando herstart. Het lijkt precies op een firmwarecrash. Lees de tutorial over het stroombudget voordat je de schuld op je code legt.
• Een bulkcondensator over elke motordriver. 470 µF dicht bij het bord. H-bruggen trekken stroom in korte pieken en de inductie van de leiding zet die pieken om in overspanningen.
• De IMU gaat op de middellijn, vlak en zo ver van de motoren als het chassis toelaat. Yaw-drift is al slecht genoeg zonder een magnetisch veld van vier motoren erbij.

Bouw hem in mijlpalen

Elke mijlpaal heeft een test. Draag een mislukking niet verder — bij een vierwielerrobot vermenigvuldigen ze zich.

1. Wielen monteren en de X-controle

Monteer de vier wielen en ga recht boven de robot staan. Volg de lijn van de rollen die je bovenop elk wiel ziet.

Test: die vier lijnen wijzen naar het midden van de robot en vormen een X. Vormen ze een ruit, verwissel dan twee wielen diagonaal. Geslaagd: een X. Dit is een controle van vijf seconden die een dag bespaart.

2. Elke motor afzonderlijk

Sluit alle vier aan en schrijf een sketch die één wiel tegelijk een seconde lang op 40% laat draaien.

Test: roep ze één voor één aan en bevestig dat het juiste wiel de juiste kant op draait. Geslaagd: vier wielen, vier juiste richtingen, geen verwisselde paren. Herstel de bedrading in hardware, niet met minteken in code — anders raak je het overzicht kwijt.

3. Encoders

Draai elk wiel met de hand één omwenteling.

Test: druk de telling af. Geslaagd: binnen 2% van 1440 en positief wanneer het wiel vooruit draait. Een telling die springt of terugloopt betekent dat je op één kanaal in plaats van twee onderbreekt, of dat je een volatile long leest zonder interrupts uit te schakelen.

4. Kinematica op blokken

Zet de robot op blokken en geef een zuivere zijwaartse beweging op.

Test: diagonale paren werken tegen elkaar in — voor links en achter rechts gaan de ene kant op, voor rechts en achter links de andere kant. Geslaagd: precies dat patroon. Geef daarna een zuivere spinopdracht: de linkerkant de ene kant op, de rechterkant de andere. Is een motor het oneens, dan staat die in de verkeerde hoek en heeft stap 1 je misleid.

5. Eén snelheidsregellus

Stel feedforward en daarna PI in op één wiel, eerst op blokken en daarna onder belasting.

Test: geef 0,3 m/s op en druk met een vinger tegen de band. Geslaagd: de snelheid blijft gelijk en de PWM stijgt zichtbaar. Doe dit één keer goed; de andere drie zijn kopieën met hun eigen kS en kV.

6. Alle vier op een rechte lijn

Vier regellussen, 100 Hz, op de vloer. Rij 3 m rechtdoor.

Test: meet de zijdelingse drift aan het einde. Geslaagd: minder dan 20 mm en reproduceerbaar over drie ritten. Bij open lus is dit doorgaans 80–200 mm en elke keer anders.

7. Rij 1 m zijwaarts

Test: rij precies één meter zijwaarts en meet zowel de afstand als de koersverandering. Geslaagd: binnen 5 cm en de koers binnen 3°. Een consistente bocht betekent dat de constante k verkeerd is; een willekeurige bocht betekent dat een snelheidsregellus niet vasthoudt.

8. IMU en veldgeoriënteerd rijden

Kalibreer de bias bij het opstarten en voeg de resetknop voor de koers toe.

Test: houd de stuurknuppel naar voren en draai de robot met de hand een volledige omwenteling. Geslaagd: hij blijft dezelfde kant op over de vloer rijden. In stilstand drift yaw minder dan 3° per minuut.

9. Het vierkant

De acceptatietest. Rij 1 m vooruit, 1 m naar rechts, 1 m terug en 1 m naar links, zonder ergens een rotatie op te geven.

Test: afstand tot het startpunt en koersverandering. Geslaagd: binnen 5 cm en 3°.

Hoe een goed resultaat eruitziet

Die laatste rij is eerlijk in plaats van teleurstellend. Bij deze aandrijving is het slippen van de rollen het mechanisme, dus de odometrie is het zwakste getal op de robot, zelfs wanneer alles werkt. Veranker die verwachting in je ontwerp in plaats van ernaar te jagen.

Hardware-opmerkingen die ertoe doen

De links-/rechthandigheid is een eigenschap van de set. Twee losse wielen die apart uit dezelfde advertentie worden besteld, hebben vaak dezelfde handigheid. Controleer dat voordat je boort.

Elke rol moet vrij kunnen draaien. Tik er met de hand tegen voordat je de wielen monteert. Een vastgelopen rol verandert die hoek in een gewoon wiel dat 45° af wijst, met onderbrekingen; dat leest precies als een softwarebug.

Mecanum-wielen zijn zwaar. 180–400 g per stuk, dus tot 1,6 kg van de robot bestaat uit wielen. Dat is roterende massa aan de uiteinden van de hefboomsarmen. De robot voelt daardoor traag en daarom is de acceleratiebovengrens belangrijk.

De vloer is een component. Gepolierd beton en vinyl hebben ongeveer μ = 0,8. Een stoffige sportvloer, een laag hairspray die iemand op een andere robot gebruikte of een naad in het linoleum halveren die waarde lokaal, waardoor het gedrag van de robot verandert terwijl hij erover rijdt. Bekijk wat μ = 0,25 doet voordat je de afstelling de schuld geeft.

Als het misgaat

Waar je daarna kunt gaan

Dode wielen. Twee of drie ongekrachtte omnidirectionele wielen op veren, elk met een eigen encoder. Ze dragen geen aandrijfkoppel en slippen dus niet, en ze maken van het slechtste getal op deze robot het beste.

Holonome padvolging. Pure pursuit en Stanley gaan uit van een bestuurbare robot met conventionele besturing. Een basis die zijwaarts kan rijden, kan beter — volg de positie op het pad en de koers onafhankelijk, want je hebt aparte actuatoren daarvoor.

Een camera op een basis die de koers vasthoudt. De natuurlijke combinatie: een beeldverwerkingspipeline is veel eenvoudiger wanneer de camera op het doel kan blijven wijzen terwijl de basis van positie verandert. Daar is holonome aandrijving werkelijk voor bedoeld.

ROS 2. Deze aandrijving is de eerste hier waarin het veld linear.y van cmd_vel — door een robot met differentiële aandrijving expliciet genegeerd — eindelijk betekenis krijgt. Het vervangen van de twist-to-wheelsfunctie door de vierregelige Mecanum-versie is het meeste werk.