Kwadratuurencoders lezen voor afstand en snelheid

Een wielencoder maakt van draaibeweging digitale pulsen. Tel die pulsen en je kunt meten hoe ver een robot heeft gereisd; tel ze over tijd en je kunt de snelheid schatten. Een kwadratuurencoder levert twee pulskanalen, A en B, die een kwart cyclus op elkaar verschoven zijn. Welk kanaal als eerste verandert, verraadt de richting.

Encoders meten relatieve beweging, geen absolute positie. De telling wordt pas zinvol na het opstarten of een doelbewuste reset, en wordt pas bruikbaar nadat je hebt gedefinieerd hoeveel tellingen precies één wielomwenteling betekenen.

Het patroon met twee kanalen lezen

De geldige kwadratuurtoestanden zijn 00, 01, 11 en 10. De ene draairichting doorloopt die reeks; de andere draait hem om. Er hoort steeds maar één bit per keer te veranderen. Een overgang zoals van 00 rechtstreeks naar 11 betekent een gemiste flank of dat ruis het signaal heeft veranderd.

Er zijn drie gangbare telmodi:

• 1×-decodering: tel één flank op kanaal A per cyclus.
• 2×-decodering: tel beide flanken op kanaal A.
• 4×-decodering: tel elke flank op beide kanalen.

Een datasheet die 12 pulsen per omwenteling opgeeft, levert dus 12, 24 of 48 softwaretellingen per encoderasomwenteling. Tel de overbrengingsverhouding erbij op als de encoder op de motor zit in plaats van op het wiel. Schrijf de volledige conventie naast de constante; onverklaarde factoren van twee en vier zijn een veelvoorkomende odometriefout.

Sluit de signalen goed aan

Bepaal of de uitgangen push-pull, open-collector of open-drain zijn. Open uitgangen hebben pull-upweerstanden nodig, die afhankelijk van de flankfrequentie en de bedrading intern of extern kunnen zijn. Controleer dat de signaalspanning veilig is voor de controller—een encoderuitgang van 5 V kan een ingang van 3,3 V beschadigen.

Houd de kabel weg van motorleidingen. Voor langere afstanden volg je de kabel- en afsluitrichtlijnen van de encoderfabrikant. Een schone digitale flank is meer waard dan proberen valse tellingen in software te repareren.

Draai het wiel langzaam met de hand voordat je de motor laat draaien. Beide kanalen moeten afwisselen tussen geldige logische niveaus. Zit er een vast, repareer dan de bedrading voordat je code debugt.

Richting decoderen zonder tellingen te verliezen

Bij bescheiden snelheden trigger je een interrupt zodra kanaal A verandert en lees je B om de richting te bepalen:

volatile long encoderCount = 0;

void onEncoderA() {
  bool a = digitalRead(ENCODER_A);
  bool b = digitalRead(ENCODER_B);
  encoderCount += (a == b) ? 1 : -1;
}

Het teken hangt af van de kanaalvolgorde en de fysieke montage. Verwissel A en B of keer het teken om, zodat voorwaartse wielbeweging een positieve telling geeft. Doe dat één keer bij de hardwaregrens in plaats van tekenwisselingen door de odometriecode te strooien.

Bij hoge flankfrequenties kunnen herhaalde digitalRead()-aanroepen te traag zijn. Gebruik een hardwarekwadratuurperifeer, een beproefde encoderbibliotheek voor het platform, of directe poorttoegang die bij de controller past. Schat het slechtste geval voordat je kiest: edges per second = counts per wheel revolution × maximum wheel revolutions per second.

Houd het werk in de interrupt kort. Werk de telling bij en keer terug. Printen, conversies naar drijvende komma en regelberekeningen horen in de hoofdlus.

Omrekenen van tellingen naar wielafstand

Laat N het aantal gedecodeerde tellingen per wielomwenteling zijn en D de effectieve wieldiameter. De wielomtrek is πD, dus:

distance = count × πD / N

Voor een wiel van 65 mm en 1.440 gedecodeerde tellingen per wielomwenteling komt elke telling overeen met ongeveer 0,142 mm. Die wiskundige resolutie is niet hetzelfde als echte nauwkeurigheid: bandcompressie, wielslip en diameterfout zijn doorgaans groter.

Lees een teller van meerdere bytes veilig af. Op een kleine microcontroller kan een interrupt hem halverwege de lezing in de hoofdlus bijwerken. Schakel interrupts kort uit of gebruik de atomaire voorziening van het platform:

noInterrupts();
long snapshot = encoderCount;
interrupts();

float distanceM = snapshot * (PI * wheelDiameterM) / countsPerWheelRev;

Gebruik een voldoende brede teller met teken en bereken het verschil tussen momentopnames. Unsigned modulaire aftrekking kan een overflow opvangen, maar alleen als de types en het monsterinterval weloverwogen gekozen zijn.

Snelheid schatten zonder ruis te versterken

Bij een vast monsterinterval bereken je het verschil in tellingen:

velocity = (newCount - oldCount) × distancePerCount / elapsedTime

Korte intervallen reageren snel, maar kwantiseren lage snelheden naar nul en sprongen van één telling. Lange intervallen zijn gladder maar voegen naloop toe. Begin vlak bij de periode van de regellus en middel dan pas over een paar monsters als de regelaar dat echt nodig heeft.

Bij zeer langzame beweging kan het meten van de tijd tussen flanken beter werken dan flanken tellen binnen een vast venster. Welke methode je ook kiest, gebruik een monotone klok voor de tijdstempels en de werkelijk verstreken tijd in plaats van aan te nemen dat elke lus perfect op schema draait.

Kalibreer op de complete aandrijflijn

Markeer het wiel en draai het precies tien omwentelingen terwijl je de tellingen registreert. Delen door tien vermindert het effect van stoppen tussen losse flanken. Laat de robot daarna over een gemeten rechte lijn rijden, vergelijk de encoderafstand met de afstand op de vloer en pas de effectieve wieldiameter aan.

Kalibreer linker- en rechterwiel apart. Meldt de robot gelijke afstanden maar rijdt hij een bocht, dan verschillen de twee effectieve diameters of de gains van de aandrijflijn. Bewaar aparte schaalfactoren; echte banden en transmissies hebben die kalibratieknop nodig.

Herhaal het bij een tweede snelheid. Een grote verandering wijst op slip, losse naven, gemiste flanken of een timingprobleem in plaats van op een eenvoudige diameterfout.

Slechte metingen diagnosticeren

• De telling verandert terwijl de robot stilstaat: elektrische ruis of zwevende ingangen; bekijk de signalen en de pull-ups.
• De telling is precies 2× of 4× verkeerd: de softwaredecodering en de pulsdefinitie uit de datasheet spreken elkaar tegen.
• De richting wisselt willekeurig: één kanaal is ruisachtig of wordt te laat afgelezen; controleer de flankkwaliteit en de decoderingsmethode.
• De tellingen bevriezen bij snelheid: de controller verwerkt de flankfrequentie niet bij; gebruik hardwaredecodering of verminder de interruptlast.
• De afstand is reproduceerbaar maar fout: kalibreer de effectieve wieldiameter en de overbrengingsverhouding.
• De afstand varieert per ondergrond: de encoder meet wielrotatie, geen waarheid; wielslip is echte onzekerheid in de beweging.

Betrouwbare tellingen zijn de invoer voor differentiaalaandrijvingsodometrie, en snelheidsterugkoppeling kan de motorlus sluiten die in de PID Controller Simulator wordt verkend. Die pose is ook de invoer die elke padvolger aanneemt, en daarom wordt zijn fout de hunne.

Volgende stap

Tellen is maar de helft. Een gemeten snelheid is de moeite waard omdat je die kunt vasthouden—zie gesloten-lusregeling op wielsnelheid, die PWM van een spanning in een snelheid verandert en voorkomt dat een robot een bocht maakt omdat één motor moe is. Op een holonome basis is dat geen extraatje meer: de vier wiel-verhoudingen zijn de sturing, en een open lus heeft niets om ze mee vast te houden.