N20-encoder-tandwielmotor

Wat het is

De N20 is de kleine motor met metalen tandwielkast die overal opduikt waar een robot veel koppel nodig heeft in heel weinig ruimte. De kale motor is ongeveer zo groot als een AA-batterij; de tandwielkast aan de voorkant ruilt zijn zeer hoge snelheid in voor bruikbaar koppel, en bij de encoderuitvoering meldt een magnetische schijf aan het achteruiteinde van de motoras hoe ver die motoras is gedraaid.

Dat laatste is wat hem een plek in een balancerende robot oplevert. Zonder wielterugkoppeling kan een balancerende robot rechtop blijven, maar weet niet waar hij is—hij blijft prachtig verticaal terwijl hij door de kamer dwaalt. De encoder sluit dat gat.

Waarom de metalen tandwielkast hier belangrijk is

Een motor met kunststof tandwielkast, zoals de TT-tandwielmotor, is prima voor een lijnvolger, die meestal vooruit rijdt. Een balancerende robot is een andere belasting: die keert continu, honderden keren per seconde, in kleine stappen om.

Elke tandwielkast heeft speling—een kleine dode zone waarin de tandwielen niet op elkaar ingrijpen en de uitgang niet beweegt totdat de tanden aan de andere kant elkaar weer raken. In een kunststof tandwielkast is die dode zone groot, en in een balancerende robot valt die precies op het moment dat de correctie het belangrijkst is: bij de omkeer, wanneer de wielen nu moeten reageren. Het resultaat is een robot die rond de verticale stand oscilleert en nooit echt stil wordt, hoe zorgvuldig de versterkingsfactoren ook zijn afgesteld.

Metalen tandwielen elimineren de speling niet, maar verminderen haar voldoende zodat de lus zijn werk kan doen. Hoeveel er overblijft, kun je in ongeveer tien minuten meten—dit is hoe.

De encoder uitlezen

De encoder levert twee blokgolven die 90° uit fase staan—standaard kwadratuur. De faseverhouding vertelt je de richting; flanken tellen vertelt je de afstand.

De draadkleuren verschillen per leverancier, dus controleer de productpagina in plaats van aan te nemen dat ze hetzelfde zijn. Wat mensen vaak overkomt, is de encoder voeden uit de motorrail: de encoder wil een schone logische voeding en krijgt hij de motorspanning, dan raakt hij beschadigd of vult hij je tellingen met ruis zodra de motor schakelt.

Plaats kanaal A op een pin die een interrupt kan veroorzaken. Een encoder pollen vanuit loop() op een balancerende robot laat tellingen vallen, en verloren tellingen betekenen dat de buitenste lus langzaam uit het oog verliest waar de robot is.

Een overbrengingsverhouding kiezen

De overbrengingsverhouding bepaalt de afweging tussen koppel en snelheid, en een balancerende robot heeft allebei nodig:

• Een te hoge verhouding (1:250 en hoger) geeft ruim voldoende koppel, maar de wielen kunnen niet snel genoeg op toerental komen om een val op te vangen.
• Een te lage verhouding (1:30 en lager) draait snel, maar kan niet voldoende koppel leveren om de massa van de robot te verplaatsen.

Ongeveer 1:100 bij 12 V — ongeveer 200 RPM — is een betrouwbaar startpunt voor een kleine robot. Als jouw robot kleine verstoringen opvangt maar grotere verliest, heb je waarschijnlijk meer snelheid nodig, niet meer regelversterking.

Aansturen

Combineer de N20 met een TB6612FNG in plaats van een L298N. De reden is spanningsverlies: de L298N verliest ongeveer 2 V over zijn uitgangstrap, waardoor een groot deel van je accu de motor nooit bereikt en kleine correctiecommando’s onder de spanning vallen waarbij de motor beweegt. Op een balancerende robot ligt die dode zone precies waar de fijne correcties plaatsvinden.

Voed hem aan vanaf een accupakket dat tegelijk de aanloopstroom van beide motoren kan leveren zonder dat de spanning inzakt—een inzakkende rail herstart de microcontroller tijdens een correctie, waarna de robot omvalt om redenen die niets met de regellus te maken hebben.

Tellingen per wielomwenteling bepalen

Dit is het getal waarop elke afstandsberekening steunt, en het is het getal dat mensen het vaakst verkeerd nemen—meestal met een factor vier.

counts per wheel revolution = PPR x 4 x gear ratio

De magnetische encoder geeft 7 pulsen per motoromwenteling op elk kanaal. Kwadratuur betekent twee kanalen die 90° uit elkaar liggen, waardoor er per pulsperiode vier telbare flanken ontstaan. En de tandwielkast betekent dat de motor zich veel keer per wielomwenteling draait.

Daarna volgt de afstand rechtstreeks:

mm per count = (pi x wheel_diameter_mm) / counts_per_revolution

In die eerste formule zitten twee valkuilen. De ×4 klopt alleen als je daadwerkelijk vier flanken telt—beide flanken op beide kanalen. Veel voorbeeldcode telt alleen stijgende flanken op kanaal A, dus dat is ×1; een ×4-constante gebruiken terwijl je ×1 telt, zet elke afstand precies vier keer verkeerd. En de overbrengingsverhouding die op de motor staat is vaak benaderend: een “1:100”-N20 is vaak 1:99,5 of 1:100,37. Kalibreer voor odometrie over afstand dus empirisch: duw de robot precies 2 m en deel.

Flanken tellen zonder er iets te missen

Bij 200 RPM door een tandwielkast van 1:100 draait de motoras 20000 RPM, wat neerkomt op 20000/60 × 7 × 4 ≈ 9300 flanken per seconde per motor. Twee motoren zijn bijna 19000 interrupts per seconde, en dat is bij volle snelheid zonder belasting.

De interrupt-handler moet echt klein zijn:

volatile long countL = 0;

// Full x4 decoding, table-driven. Both channels, both edges.
const int8_t QUAD_TABLE[16] = {0,-1,1,0, 1,0,0,-1, -1,0,0,1, 0,1,-1,0};
volatile uint8_t prevL = 0;

void isrLeft() {
  uint8_t now = (digitalRead(ENC_L_A) << 1) | digitalRead(ENC_L_B);
  countL += QUAD_TABLE[(prevL << 2) | now];
  prevL = now;
}

void setup() {
  pinMode(ENC_L_A, INPUT_PULLUP);
  pinMode(ENC_L_B, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(ENC_L_A), isrLeft, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ENC_L_B), isrLeft, CHANGE);
}

long readCount() {           // long is not atomic on an 8-bit AVR
  noInterrupts();
  long v = countL;
  interrupts();
  return v;
}

Drie details die ertoe doen:

volatile, en een atomaire lezing. Een long is vier bytes op een AVR en wordt byte voor byte gelezen. Een interrupt die midden in de lezing komt, levert een waarde die half oud en half nieuw is—dat veroorzaakt af en toe een enorme sprong in je odometrie, willekeurig, ongeveer één keer per enkele duizenden lezingen.

De opzoektabel decodeert de overgang in plaats van de richting uit één kanaal te gokken. Ze wijst ook vanzelf ongeldige overgangen af (beide bits wisselen tegelijk, dus je hebt er een gemist) door nul bij te dragen.

Pinbezetting. Volledige ×4-decodering op twee motoren vraagt vier pinnen die interrupts kunnen afhandelen, en een Arduino Uno heeft er precies twee. De opties zijn: ×2-decodering gebruiken (één kanaal per motor, CHANGE), waardoor de resolutie halveert maar de richting behouden blijft; overschakelen naar een bord met meer interrupt-pins, zoals een Mega of ESP32; of pin-change-interrupts gebruiken, die elke AVR-pin ondersteunt maar waarbij je een hele poort tegelijk moet afhandelen.

Snelheid uit tellingen

Positie is een telling. Snelheid vraagt een verschil over tijd, en de manier waarop je dat neemt bepaalt of je regellus bruikbaar is.

long lastCount = 0;
unsigned long lastMicros = 0;

float speedMmPerSec() {
  long   c  = readCount();
  unsigned long t = micros();

  float dt = (t - lastMicros) * 1e-6f;
  if (dt < 0.005f) return lastSpeed;        // too short: quantisation dominates

  float mm = (c - lastCount) * MM_PER_COUNT;
  lastCount = c; lastMicros = t;

  lastSpeed = mm / dt;
  return lastSpeed;
}

De dt-beveiliging is de belangrijke regel. Meet je te snel en je deelt een verschil van één of twee tellingen door een heel klein tijdsinterval, waardoor de kwantisatiefout overheerst en de “snelheid” grotendeels ruis is—een differentiatielid in een PID-lus versterkt dat daarna enthousiast.

Er zijn twee eerlijke manieren om snelheid uit een encoder te meten, en ze passen bij verschillende uiteinden van het bereik. Flanken tellen in een vast venster (de code hierboven) is goed bij hoge snelheid en slecht bij lage snelheid, waar per venster weinig flanken binnenkomen. Het interval tussen flanken meten is het omgekeerde: uitstekend bij lage snelheid, ruisachtig bij hoge snelheid. Een robot die beide uiteinden nodig heeft, schakelt meestal bij een drempel.

Problemen oplossen

N20 of TT-tandwielmotor?

De doorslaggevende factor is zelden het koppel en vrijwel altijd speling en terugkoppeling. Een lijnvolger rijdt meestal vooruit en stuurt met een sensor die naar de vloer kijkt; hij merkt nooit de speling van de tandwielkast, en een TT-motor is het juiste, goedkope antwoord. Een balancerende robot keert honderden keren per seconde in kleine stappen om, dus de dode zone bij elke omkeer is precies waar zijn correctie moet werken, en kunststof tandwielen maken de lus instabiel hoe goed je die ook afstelt.

Dezelfde logica geldt voor een doolhofoplosser: die navigeert door afstand te tellen, dus verloren beweging bij elke bocht telt meteen op tot een positiefout.

Gebruikt in

• Zelfbalancerende robot — de aandrijfmotoren, met de encoders die de buitenste positielus voeden