N20-Getriebemotor mit Encoder

Was es ist

Der N20 ist der kleine Metallgetriebemotor, der überall auftaucht, wo ein Roboter echtes Drehmoment auf kleinstem Raum braucht. Der nackte Motor ist etwa so groß wie eine AA-Batterie; das Getriebe vorne tauscht seine sehr hohe Drehzahl gegen brauchbares Drehmoment, und in der Encoderversion meldet eine Magnetscheibe auf der hinteren Welle, wie weit er sich gedreht hat.

Der letzte Teil verschafft ihm seinen Platz im Balancierroboter. Ohne Rad-Feedback kann ein Balancierroboter aufrecht bleiben, weiß aber nicht, wo er ist – er hält die Vertikale wunderbar und wandert dabei durch den Raum. Der Encoder schließt diese Lücke.

Warum das Metallgetriebe hier zählt

Ein Kunststoffgetriebemotor wie der TT-Getriebemotor reicht völlig für einen Linienfolger, der meist vorwärts fährt. Ein Balancierroboter ist eine andere Last: Er kehrt die Richtung fortlaufend um, hunderte Male pro Sekunde, in kleinen Schritten.

Jedes Getriebe hat Spiel – eine kleine Totzone, in der die Zahnräder ausgehängt sind und der Abtrieb sich nicht bewegt, bis die Zähne auf der anderen Seite wieder greifen. In einem Kunststoffgetriebe ist diese Totzone groß – und im Balancierroboter landet sie genau dort, wo die Korrektur am meisten zählt: im Umkehrmoment, wenn die Räder jetzt reagieren müssen. Heraus kommt ein Roboter, der um die Vertikale schwingt und sich nie ganz beruhigt – egal wie sorgfältig die Verstärkungen abgestimmt wurden.

Metallzahnräder beseitigen Spiel nicht, verringern es aber so weit, dass die Schleife ihre Arbeit tun kann. Wie viel übrig ist, lässt sich in etwa zehn Minuten messen – so geht es.

Den Encoder auslesen

Der Encoder erzeugt zwei um 90° versetzte Rechteckwellen – Standard-Quadratur. Die Phasenbeziehung sagt die Richtung; Flankenzählen sagt die Strecke.

Leitungsfarben streuen zwischen Lieferanten – also die Artikelbeschreibung prüfen statt annehmen. Der Fang ist, den Encoder an der Motorschiene zu versorgen: Der Encoder will eine saubere Logikversorgung – Motorspannung darauf zerstört ihn entweder oder füllt die Zählwerte bei jedem Motorschalten mit Rauschen.

Kanal A auf einen interruptfähigen Pin legen. Einen Encoder in loop() zu pollen verliert an einem Balancierroboter Zählwerte – und verlorene Zählwerte heißen: Die äußere Schleife verliert langsam den Überblick, wo der Roboter ist.

Eine Untersetzung wählen

Die Untersetzung setzt den Tausch zwischen Drehmoment und Drehzahl – und ein Balancierroboter braucht beides:

• Zu hohe Untersetzung (1:250 und mehr) liefert reichlich Drehmoment, aber die Räder drehen nicht schnell genug hoch, um unter einen fallenden Körper zurückzukommen.
• Zu niedrige Untersetzung (1:30 und darunter) dreht schnell, bewegt die Robotermasse aber nicht mit Autorität.

Um 1:100 an 12 V – grob 200 U/min – ist ein verlässlicher Startpunkt für einen kleinen Roboter. Fängt deiner kleine Störungen ab, verliert aber größere, brauchst du wahrscheinlich mehr Drehzahl, nicht mehr Verstärkung.

Ansteuern

Den N20 mit einem TB6612FNG paaren statt L298N. Der Grund ist Dropout: Der L298N verliert grob 2 V über seiner Ausgangsstufe – ein großer Teil der Batterie erreicht den Motor also nie, und kleine Korrekturbefehle fallen unter die Spannung, ab der sich der Motor überhaupt bewegt. Am Balancierroboter sitzt diese Totzone genau dort, wo die feinen Korrekturen leben.

Von einem Akkupack versorgen, das den Blockierstrom beider Motoren zugleich liefern kann, ohne dass seine Spannung einbricht – eine einbrechende Schiene setzt den Mikrocontroller mitten in der Korrektur zurück, und der Roboter fällt aus Gründen um, die nichts mit deiner Regelschleife zu tun haben.

Zählwerte pro Radumdrehung ausrechnen

Das ist die Zahl, von der jede Streckenrechnung abhängt – und die, die Leute am häufigsten falsch haben, meist um Faktor vier.

counts per wheel revolution = PPR x 4 x gear ratio

Der Magnetencoder liefert 7 Impulse pro Motorumdrehung auf jedem Kanal. Quadratur heißt: zwei Kanäle um 90° versetzt, was vier zählbare Flanken pro Impulsperiode ergibt. Und das Getriebe heißt: Der Motor dreht sich vielfach pro Radumdrehung.

Daraus folgt die Strecke direkt:

mm per count = (pi x wheel_diameter_mm) / counts_per_revolution

Zwei Fallen stecken in der ersten Formel. Das ×4 gilt nur, wenn man wirklich vier Flanken zählt – beide Flanken auf beiden Kanälen. Mancher Beispielcode zählt nur steigende Flanken auf Kanal A, was ×1 ist – und eine ×4-Konstante mit ×1-Zählung legt jede Strecke um exakt vier daneben. Und die aufgedruckte Untersetzung ist oft näherungsweise: Ein „1:100“-N20 ist häufig 1:99,5 oder 1:100,37. Für Odometrie über Strecke stattdessen empirisch kalibrieren: Den Roboter exakt 2 m schieben und teilen.

Die Flanken zählen, ohne eine zu verlieren

Bei 200 U/min über ein 1:100-Getriebe dreht die Motorwelle 20000 U/min, was 20000/60 × 7 × 4 ≈ 9300 Flanken pro Sekunde pro Motor ergibt. Zwei Motoren sind fast 19000 Interrupts pro Sekunde – und das bei Volldrehzahl ohne Last.

Der Interrupthandler muss wirklich klein sein:

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

Drei Details, auf die es ankommt:

volatile und atomares Lesen. Ein long sind vier Bytes auf einem AVR, byteweise gelesen. Ein Interrupt mitten in der Lesung liefert einen halb alten, halb neuen Wert – was gelegentlich einen riesigen Sprung in der Odometrie erzeugt, zufällig, grob einmal in wenigen tausend Lesungen.

Die Nachschlagetabelle dekodiert den Übergang statt die Richtung aus einem Kanal zu raten. Sie verwirft ungültige Übergänge (beide Bits wechseln zugleich – was heißt: einen verpasst) von Natur aus, indem sie null beiträgt.

Pindruck. Volle ×4-Dekodierung an zwei Motoren braucht vier interruptfähige Pins, und ein Arduino Uno hat exakt zwei. Die Optionen: ×2-Dekodierung (ein Kanal pro Motor, CHANGE) – halbiert Auflösung, liefert weiter Richtung; auf ein Board mit mehr Interrupts wechseln wie Mega oder ESP32; oder Pin-Change-Interrupts, die jeder AVR-Pin unterstützt, aber einen ganzen Port auf einmal zu behandeln verlangen.

Drehzahl aus Zählwerten

Position ist ein Zählwert. Drehzahl braucht eine Differenz über Zeit – und wie man sie nimmt, entscheidet, ob die Regelschleife brauchbar ist.

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

Die dt-Wache ist die wichtige Zeile. Zu schnell abgetastet, und man teilt eine Differenz von ein, zwei Zählwerten durch ein winziges Intervall – der Quantisierungsfehler dominiert und die „Drehzahl“ ist meist Rauschen, das ein D-Anteil in einer PID-Schleife dann begeistert verstärkt.

Es gibt zwei ehrliche Arten, Drehzahl aus einem Encoder zu messen, und sie passen zu verschiedenen Enden des Bereichs. Flanken in einem festen Fenster zählen (der Code oben) ist gut bei hoher Drehzahl und schwach bei niedriger, wo wenige Flanken pro Fenster eintreffen. Das Intervall zwischen Flanken messen ist umgekehrt: hervorragend bei niedriger Drehzahl, verrauscht bei hoher. Ein Roboter, der beide Enden braucht, schaltet meist an einer Schwelle um.

Fehlersuche

N20- oder TT-Getriebemotor?

Der entscheidende Faktor ist selten Drehmoment und fast immer Spiel und Feedback. Ein Linienfolger fährt meist vorwärts und lenkt nach einem Sensor, der auf den Boden schaut – Getriebespiel bemerkt er nie, und ein TT-Motor ist die richtige, billige Antwort. Ein Balancierroboter kehrt die Richtung hunderte Male pro Sekunde in winzigen Schritten um – die Totzone bei jeder Umkehr liegt also exakt dort, wo seine Korrektur wirken muss, und Kunststoffzahnräder machen die Schleife instabil, egal wie sie abgestimmt ist.

Dieselbe Logik gilt für einen Labyrinthlöser: Er navigiert per Streckenzählung – verlorene Bewegung an jeder Drehung summiert sich also direkt in Positionsfehler.

Verwendet in

• Selbstbalancierender Roboter – die Antriebsmotoren, mit den Encodern in der äußeren Positionsschleife