Bauteile · 11 Min. Lesezeit

Getriebemotor am Arduino: TT-Motor, Drehzahl, PWM und Encoder

Was ist ein Getriebemotor (gelber TT-Motor)? Übersetzung 1:48, Drehzahl, Drehmoment, 3–6 V, Strom messen, Gleichlauf per PWM, Entstörkondensator, Encoder, N20.

Ein Getriebemotor ist ein kleiner, schneller Gleichstrommotor, an dessen Welle ein Getriebe (Untersetzung) sitzt, das die Drehzahl senkt und das Drehmoment erhöht. Der gelbe TT-Motor mit Kunststoffgehäuse, den du an Arduino-Roboterautos siehst, ist der verbreitetste Vertreter dieser Familie: Der Motor im Inneren dreht sich tausende Male pro Minute, doch dank der Zahnräder dreht sich das Rad nur 100–250-mal pro Minute und hat genug Kraft, um ein Auto mühelos anzutreiben. Er wird meist als Set mit einem 65-mm-Gummirad verkauft und läuft mit 3–6 V.

In dieser Anleitung lernst du, wie die Übersetzung (1:48) Drehzahl und Drehmoment verändert, welche Spannungs-, Strom- und Drehzahlwerte der TT-Motor hat, wie du den Motorstrom misst und den richtigen Motortreiber wählst. Danach siehst du, warum zwei Motoren beim gleichen PWM-Wert unterschiedlich schnell drehen, und gleichst sie erst per Software und dann mit einer Encoderscheibe an. Außerdem findest du Entstörkondensatoren, Code für ESP32 und Raspberry Pi Pico und einen Vergleich mit dem N20-Mikromotor.

Gelber TT-Getriebemotor mit Rad
Gelber TT-Motor mit 65-mm-Rad: Getriebe 1:48, 3–6 V Betriebsspannung und eine Welle, die auf beiden Seiten herauskommt.

Was ist ein Getriebemotor und wie funktioniert er?

Ein gewöhnlicher kleiner Gleichstrommotor dreht im Leerlauf mit 8.000–10.000 U/min, hat aber sehr wenig Drehmoment; direkt an einem Rad bewegt er das Auto nicht. Das Getriebe senkt diese hohe Drehzahl mit ineinandergreifenden Zahnrädern und erhöht das Drehmoment im gleichen Verhältnis. Bei einer Übersetzung von 1:48 dreht sich die Abtriebswelle einmal, während die Motorwelle 48 Umdrehungen macht: Die Drehzahl wird durch 48 geteilt, das Drehmoment (abzüglich Reibungsverluste im Getriebe) ungefähr mit 48 multipliziert. Die Leistung (Drehmoment × Drehzahl) bleibt gleich; das Getriebe tauscht nur Geschwindigkeit gegen Kraft. Deshalb sind Getriebemotoren ideal für langsame, aber kräftige Bewegungen wie Räder, Seilwinden, Türen oder Förderbänder.

EigenschaftGelber TT-Motor (1:48, typische Werte)
Betriebsspannung3–6 V DC
Übersetzung1:48 (es gibt auch 1:120 und 1:220)
Leerlaufdrehzahl am AbtriebEtwa 90–120 U/min bei 3 V, etwa 200–250 U/min bei 6 V
LeerlaufstromEtwa 150 mA
BlockierstromEtwa 1,2 A bei 4,5 V, etwa 1,5 A bei 6 V
BlockiermomentEtwa 0,4 kg·cm bei 3 V, etwa 0,8 kg·cm bei 6 V
WelleBeidseitige Kunststoffwelle mit zwei Abflachungen
Gehäuse und ZahnräderKunststoff; etwa 70 × 22 × 18 mm, 30 g
RadEtwa 65 mm Durchmesser, Gummi

Übersetzung, Drehzahl und Drehmoment berechnen

Um einen Motor auszuwählen oder abzuschätzen, wie schnell ein Roboter fährt, genügen ein paar einfache Rechnungen. Der Radumfang ist π × Durchmesser: bei einem 65-mm-Rad 3,14 × 6,5 ≈ 20,4 cm. Ein Rad, das bei 6 V im Leerlauf mit 200 U/min dreht, legt pro Minute 200 × 20,4 = 4080 cm zurück, also etwa 0,68 m/s; unter Last sinkt der Wert um 20–30 %. Beim Drehmoment entsprechen 0,8 kg·cm am Radius von 3,25 cm einer Schubkraft von 0,8 / 3,25 ≈ 0,25 kg; mehr kann der Motor nicht liefern, bevor er stehen bleibt. Dauerhaft sollte ein Motor nicht mit mehr als etwa einem Drittel seines Blockiermoments belastet werden.

ÜbersetzungAbtriebsdrehzahl (6 V, Leerlauf)DrehmomentGeeignet für
1:48Etwa 200–250 U/minMittelRoboterauto, Linienfolger, Hindernisvermeider
1:120Etwa 80–100 U/minHochAuto mit schwerer Last, langsame und kontrollierte Bewegung
1:220Etwa 45–55 U/minSehr hochTür, Vorhang, Drehteller, Sonnennachführung
Schnell, aber schwach, oder langsam, aber kräftig: Mit der Übersetzung bekommst du nicht beides. Für ein Rennauto reicht 1:48; für einen Roboter, der eine Rampe hochfahren oder eine schwere Last aus Akkus, Sensoren und Display tragen muss, ist 1:120 sicherer. Bei der Akkuwahl kannst du die Gesamtkapazität mit dem Akkulaufzeit-Rechner prüfen.

Mit welcher Spannung läuft ein TT-Motor?

Die Nennspannung des TT-Motors liegt bei 3–6 V, und in diesem Bereich ändert sich die Drehzahl fast proportional zur Spannung. Die verbreitetste Stromquelle sind 4 AA-Batterien: Neue Alkalizellen liefern 6,0–6,4 V, NiMH-Akkus 4,8–5,2 V. Zwei 18650-Li-Ionen-Zellen liefern voll geladen 8,4 V, was für einen 6-V-Motor zu viel ist; Treiber wie der L298N verlieren aber etwa 2 V, sodass am Motor rund 6 V ankommen. Mit einem effizienteren Treiber kannst du den maximalen PWM-Wert begrenzen: Um aus 8,4 V im Mittel 6 V zu erhalten, nimm höchstens 255 × 6 / 8,4 ≈ 182. Details zur Akkuwahl stehen in den Artikeln Arduino mit Batterie betreiben und Akkukapazität in mAh.

Versorge den Motor niemals direkt über den 5V-Pin oder einen Digitalpin des Arduino. Ein Pin liefert höchstens 20–40 mA; der TT-Motor zieht schon im Leerlauf 150 mA und blockiert 1,5 A. Außerdem erzeugt der Motor beim Anhalten eine Gegenspannung (Gegen-EMK). Betreibe den Motor immer über einen Treiber (L298N, L9110S, TB6612FNG) oder einen MOSFET mit Diode an einer eigenen Batterie, deren Minuspol mit dem GND des Arduino verbunden ist.

Den Motorstrom messen

Kennst du den Strom, kannst du den richtigen Treiber wählen und ausrechnen, wie lange der Akku hält. Am einfachsten stellst du ein Multimeter auf Strommessung und schaltest es in Reihe mit dem Motor: Steck die rote Messleitung in die 10-A-Buchse, löse das Kabel vom Pluspol der Batterie und setz das Multimeter dazwischen. Miss zuerst mit dem Motor in der Luft (Leerlauf), dann mit dem Roboter auf dem Boden und zuletzt, indem du das Rad kurz mit der Hand festhältst. Wie man ein Multimeter benutzt, zeigt Multimeter richtig benutzen; um den Strom laufend mit dem Arduino zu überwachen, lies den Artikel Stromsensor ACS712.

SituationTypischer Strom (6 V)Was bedeutet das?
Rad in der Luft, Leerlauf150–170 mAReibung in Getriebe und Bürsten; der Motor ist in Ordnung
Roboter fährt auf ebenem Boden200–350 mANormalbetrieb; diesen Wert für die Akkurechnung nehmen
Rampe oder Teppich400–700 mADer Motor müht sich; 1:120 oder ein leichteres Chassis erwägen
Rad blockiert1,2–1,5 ASchlimmster Fall für Treiber und Akku; dauert es an, wird der Motor heiß
AnfahrenKurzzeitig bis 1 AKann die Akkuspannung einbrechen lassen und den Arduino zurücksetzen

Daraus ergibt sich die Laufzeit leicht: Ein Roboter, dessen zwei Motoren auf ebenem Boden zusammen 0,6 A ziehen, fährt mit 2000-mAh-NiMH-Akkus etwa 2000 / 600 ≈ 3,3 Stunden. Für die Treiberwahl zählt der Blockierstrom: Der L9110S liefert etwa 800 mA pro Kanal und ist für TT-Motoren grenzwertig; der TB6612FNG mit 1,2 A Dauer- und 3,2 A Spitzenstrom pro Kanal hat mehr Reserve. Um Strom, Spannung und Widerstand schnell zu berechnen, kannst du den Ohmsches-Gesetz-Rechner nutzen.

Motortreiber wählen und anschließen

L298N-Doppelmotortreiber
Das L298N-Modul kann zwei TT-Motoren gleichzeitig treiben; weil es aber etwa 2 V verliert, bekommen die Motoren weniger als die Akkuspannung.
TreiberStrom pro KanalSpannungsabfallHinweis
L298N2 AEtwa 1,5–2,5 VRobust und verbreitet; mit 4×AA bleiben am Motor etwa 4–4,5 V
L293D (Shield)0,6 A (Spitze 1,2 A)Etwa 1,5–2,5 VWird auf den Uno gesteckt, treibt vier Motoren; für TT grenzwertig
L9110S0,8 AGeringKlein und günstig; beim Blockierstrom überfordert
TB6612FNG1,2 A (Spitze 3,2 A)Sehr gering (MOSFET)Nutzt die Akkuspannung effizient, eine der besten Wahlen für TT
VerbindungArduino UnoESP32Raspberry Pi Pico
L298N ENA (Drehzahl linker Motor, PWM)D5GPIO 25GP15
L298N IN1 / IN2D7 / D8GPIO 27 / GPIO 33GP14 / GP13
L298N ENB (Drehzahl rechter Motor, PWM)D6GPIO 26GP10
L298N IN3 / IN4D9 / D4GPIO 32 / GPIO 4GP12 / GP11
Ausgang linker / rechter Encoder (LM393)D2 / D3GPIO 34 / GPIO 35GP16 / GP17
VCC des Encodermoduls5V3V33V3(OUT)
GNDBatterie-Minus, L298N und Arduino-GND gemeinsamGemeinsamGemeinsam

Vergiss nicht, die Jumper an ENA und ENB zu entfernen; bleiben sie stecken, ignoriert der Motor das PWM-Signal und läuft immer mit voller Drehzahl. Alle Pins des L298N sowie Bremsen und Auslaufen erklärt der Artikel DC-Motor mit L298N ausführlich. Dreht ein Motor falsch herum, ist es am saubersten, seine beiden Kabel am Treiber zu tauschen, statt den Code zu ändern.

Arduino-Code: vorwärts, rückwärts, drehen und Drehzahl angleichen

C++ (Arduino IDE)
1// İki TT motoru L298N ile: ileri, geri, dönüş ve hız dengeleme
2// Two TT motors with an L298N: forward, reverse, turning and speed trim
3const byte ENA = 5, IN1 = 7, IN2 = 8;    // sol motor / left motor
4const byte ENB = 6, IN3 = 9, IN4 = 4;    // sağ motor / right motor
5const int MIN_PWM = 70;                  // altında motor kalkamaz / below this the motor won't start
6const float SOL_KATSAYI = 1.00;          // hızlı motoru yavaşlatmak için / to slow the faster motor
7const float SAG_KATSAYI = 0.92;
8
9void motorSur(byte en, byte inA, byte inB, int hiz, float katsayi) {   // hiz: -255..255
10  int pwm = abs(hiz) * katsayi;
11  if (pwm > 0 && pwm < MIN_PWM) pwm = MIN_PWM;    // ölü bölgeyi atla / skip the dead zone
12  digitalWrite(inA, hiz > 0 ? HIGH : LOW);
13  digitalWrite(inB, hiz < 0 ? HIGH : LOW);
14  analogWrite(en, hiz == 0 ? 0 : pwm);
15}
16
17void sur(int sol, int sag) {
18  motorSur(ENA, IN1, IN2, sol, SOL_KATSAYI);
19  motorSur(ENB, IN3, IN4, sag, SAG_KATSAYI);
20}
21
22void setup() {
23  byte pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
24  for (byte p : pinler) pinMode(p, OUTPUT);
25}
26
27void loop() {
28  sur(200, 200);    // ileri / forward
29  delay(2000);
30  sur(0, 0);        // dur / stop
31  delay(500);
32  sur(-180, -180);  // geri / reverse
33  delay(1500);
34  sur(0, 0);
35  delay(500);
36  sur(180, -180);   // yerinde sağa dön / spin right in place
37  delay(600);
38  sur(0, 0);
39  delay(1500);
40}

MIN_PWM im Code ist der kleinste PWM-Wert, bei dem der Motor die Haftreibung überwindet und anläuft. Die Pins 5 und 6 des Uno erzeugen PWM mit etwa 980 Hz; TT-Motoren brummen unterhalb eines Werts zwischen 60 und 90 meist nur, ohne sich zu drehen. Den Wert für deinen Motor findest du leicht: Beginne bei PWM 0, erhöhe in Fünferschritten und notiere den Wert, bei dem sich das Rad zum ersten Mal dreht. Wie PWM funktioniert und was es mit der Frequenz auf sich hat, erklärt Was ist PWM?.

Warum drehen zwei Motoren unterschiedlich schnell?

Gibst du zwei TT-Motoren aus derselben Packung denselben PWM-Wert, erwartest du, dass der Roboter geradeaus fährt, doch meist zieht das Auto zu einer Seite. Der Grund sind Fertigungsunterschiede bei günstigen Motoren: Toleranzen von Bürsten und Magneten, Reibung im Getriebe, Schmierung und die Ausrichtung der Kunststoffwellen sind bei jedem Motor etwas anders. Die von Händlern genannten ±10 % Toleranz können zwischen zwei Motoren bis zu 20 % Drehzahlunterschied bedeuten. Dazu ist der Unterschied nicht konstant: Er ändert sich, wenn die Akkuspannung sinkt, der Motor warm wird oder der Untergrund wechselt. Und weil die Motoren spiegelverkehrt montiert sind, dreht einer aus Motorsicht vorwärts, der andere rückwärts, und manche Motoren sind in beiden Richtungen unterschiedlich schnell.

  1. Lass den Roboter auf ebenem Boden 2–3 Meter mit gleichem PWM vorwärts fahren und notiere, wohin er zieht.
  2. Zieht das Auto nach rechts, ist der linke Motor schneller; senke SOL_KATSAYI auf 0,95 und probiere es erneut.
  3. Ändere den Faktor in Schritten von 0,01–0,02, bis das Auto geradeaus fährt; das dauert meist 3–5 Versuche.
  4. Mach denselben Test rückwärts; ist der Unterschied groß, nutze getrennte Faktoren für vorwärts und rückwärts.
  5. Ändert sich die Akkuspannung, kann die Einstellung wieder abweichen; für eine dauerhafte, selbstkorrigierende Lösung wechsle zur Encoder-Methode unten.

Störungen beseitigen: Entstörkondensatoren am Motor

Wenn sich Bürstenmotoren drehen, entstehen zwischen Bürsten und Kommutator kleine Funken. Sie verursachen Spannungsspitzen auf der Versorgungsleitung und elektrische Störungen, die in die Umgebung abgestrahlt werden. Die Symptome kennst du: Der Arduino startet neu, sobald der Motor läuft, im seriellen Monitor erscheinen wirre Zeichen, der Ultraschallsensor misst unsinnige Entfernungen oder die Bluetooth-Verbindung bricht ab. Die Lösung ist, die Störungen an der Quelle, direkt am Motor, zu unterdrücken.

  • 100 nF zwischen die Motoranschlüsse: Löte zwischen die beiden Anschlüsse jedes Motors einen 100-nF-Keramikkondensator mit der Aufschrift 104. Halte die Beinchen so kurz wie möglich.
  • Zwei weitere zum Gehäuse: Bei Motoren mit Metallgehäuse senkt je ein 100 nF von jedem Anschluss zum Gehäuse die Störungen weiter. Das Gehäuse des TT-Motors ist aus Kunststoff, daher genügt meist der eine Kondensator zwischen den Anschlüssen.
  • Elko an der Treiberversorgung: Setz an den Versorgungseingang des L298N einen Elektrolytkondensator mit 470–1000 µF; er dämpft den Spannungseinbruch beim Anfahren.
  • Kabel verdrillen: Verdrille die beiden Motorkabel miteinander; so strahlen die Leitungen weniger Störungen ab.
  • Versorgungen trennen: Versorge Arduino und Motoren möglichst aus getrennten Batterien und verbinde die GNDs an einem einzigen Punkt.

Wie Kondensatoren funktionieren und wie man ihre Aufdrucke liest, steht in Was ist ein Kondensator?, weitere Ursachen für Resets bei laufendem Motor in Arduino startet ständig neu.

Drehzahl mit einer Encoderscheibe messen

Die Welle des TT-Motors kommt auf beiden Seiten heraus; auf das Ende ohne Rad steckst du meist die Kunststoff-Encoderscheibe mit 20 Schlitzen, die dem Set beiliegt. Die Schlitze laufen durch eine U-förmige Infrarot-Gabellichtschranke (ein optisches Modul mit LM393-Komparator), und jeder Schlitz erzeugt einen Impuls. Da sich die Scheibe genauso schnell dreht wie das Rad, bedeuten 20 Impulse eine Radumdrehung. Werden in einer halben Sekunde 30 Impulse gezählt, hat sich das Rad 30 / 20 = 1,5-mal gedreht, also mit 1,5 × 120 = 180 U/min. Multiplizierst du die Umdrehungen mit dem Radumfang, erhältst du auch die gefahrene Strecke: Jeder Impuls entspricht etwa 20,4 / 20 ≈ 1 cm.

Der folgende Code misst die Drehzahl beider Räder und passt den PWM-Wert des rechten Motors automatisch an, bis beide Seiten gleich viele Impulse zählen. Das ist ein einfacher Proportionalregler (P-Regler): Je größer die Abweichung, desto größer die Korrektur. Weil Gabellichtschranken an einer Kante mehrere Impulse erzeugen können, ignoriert die Interrupt-Funktion Impulse, die weniger als 2 ms auseinanderliegen. Details zu Interrupts stehen im Artikel Arduino Interrupts.

C++ (Arduino IDE)
1// 20 yarıklı enkoder diskiyle devir ölçümü ve iki motoru eşitleme
2// RPM measurement with 20-slot encoder discs and matching two motors
3const byte ENA = 5, IN1 = 7, IN2 = 8;      // sol motor / left motor
4const byte ENB = 6, IN3 = 9, IN4 = 4;      // sağ motor / right motor
5const byte ENC_SOL = 2, ENC_SAG = 3;       // LM393 yarık sensörleri / slot sensors
6const byte YARIK = 20;                     // disk başına yarık / slots per disc
7const int TEMEL_PWM = 180;                 // sol motorun sabit hızı / fixed left speed
8const float KP = 4.0;                      // oransal kazanç / proportional gain
9
10volatile unsigned int solSayac = 0, sagSayac = 0;
11volatile unsigned long solSon = 0, sagSon = 0;
12int sagPwm = TEMEL_PWM;
13unsigned long oncekiZaman = 0;
14
15void solDarbe() {
16  unsigned long t = micros();
17  if (t - solSon > 2000) {                 // 2 ms'den yakın darbeleri yok say / ignore bounces
18    solSayac++;
19    solSon = t;
20  }
21}
22
23void sagDarbe() {
24  unsigned long t = micros();
25  if (t - sagSon > 2000) {
26    sagSayac++;
27    sagSon = t;
28  }
29}
30
31void setup() {
32  Serial.begin(9600);
33  byte pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
34  for (byte p : pinler) pinMode(p, OUTPUT);
35  pinMode(ENC_SOL, INPUT);
36  pinMode(ENC_SAG, INPUT);
37  attachInterrupt(digitalPinToInterrupt(ENC_SOL), solDarbe, RISING);
38  attachInterrupt(digitalPinToInterrupt(ENC_SAG), sagDarbe, RISING);
39  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);   // iki motor da ileri / both forward
40  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
41  analogWrite(ENA, TEMEL_PWM);
42  analogWrite(ENB, sagPwm);
43}
44
45void loop() {
46  if (millis() - oncekiZaman >= 500) {     // yarım saniyede bir / every half second
47    oncekiZaman = millis();
48    noInterrupts();
49    unsigned int sol = solSayac, sag = sagSayac;
50    solSayac = 0;
51    sagSayac = 0;
52    interrupts();
53
54    float solDevir = sol * 120.0 / YARIK;  // 0,5 s'deki darbe -> d/dk / pulses in 0.5 s -> rpm
55    float sagDevir = sag * 120.0 / YARIK;
56    sagPwm += (int)(KP * ((int)sol - (int)sag));    // sağ geride kaldıysa hızlandır / speed up if behind
57    sagPwm = constrain(sagPwm, 70, 255);
58    analogWrite(ENB, sagPwm);
59
60    Serial.print(F("Sol / Left: "));
61    Serial.print(solDevir, 0);
62    Serial.print(F(" d/dk  Sag / Right: "));
63    Serial.print(sagDevir, 0);
64    Serial.print(F(" d/dk  Sag PWM: "));
65    Serial.println(sagPwm);
66  }
67}

Beim Ausführen siehst du im seriellen Monitor, wie sich der rechte PWM-Wert in den ersten Sekunden ändert und sich dann die Drehzahlen beider Räder angleichen. Ist KP zu groß, schwingt der rechte Motor zwischen schneller und langsamer; ist er zu klein, korrigiert er träge; Werte zwischen 2 und 6 sind ein guter Start. Für präziseres Fahren kannst du auch die Gesamtstrecke angleichen oder einen vollständigen PID-Regler schreiben. Der Encodersensor arbeitet ähnlich wie die Infrarotsensoren in Linienfolgern; Details im Artikel Infrarotsensor TCRT5000.

TT-Motor mit dem ESP32 steuern

Die 3,3-V-Pins des ESP32 steuern die Eingänge von L298N und TB6612FNG problemlos, weil diese Treiber alles über 2,3 V als HIGH erkennen. Der ESP32-Arduino-Core unterstützt analogWrite; die Standard-PWM-Frequenz liegt bei etwa 1 kHz. Versorge die Encodersensoren mit 3V3, damit auch ihre Ausgänge 3,3 V liefern; GPIO 34 und 35 sind reine Eingänge und ideal für die Encoder. Dank WLAN und Bluetooth des ESP32 kannst du den Roboter per Handy steuern und die Drehzahl auf einer Webseite anzeigen.

C++ (Arduino IDE)
1// ESP32: iki TT motor, enkoderle devir ölçümü / two TT motors with RPM measurement
2const int ENA = 25, IN1 = 27, IN2 = 33;      // sol motor / left motor
3const int ENB = 26, IN3 = 32, IN4 = 4;       // sağ motor / right motor
4const int ENC_SOL = 34, ENC_SAG = 35;        // yalnız giriş pinleri / input-only pins
5const int YARIK = 20;
6
7volatile uint32_t solSayac = 0, sagSayac = 0;
8portMUX_TYPE kilit = portMUX_INITIALIZER_UNLOCKED;
9
10void IRAM_ATTR solDarbe() {
11  portENTER_CRITICAL_ISR(&kilit);
12  solSayac++;
13  portEXIT_CRITICAL_ISR(&kilit);
14}
15
16void IRAM_ATTR sagDarbe() {
17  portENTER_CRITICAL_ISR(&kilit);
18  sagSayac++;
19  portEXIT_CRITICAL_ISR(&kilit);
20}
21
22void sur(int sol, int sag) {                 // -255..255
23  digitalWrite(IN1, sol > 0); digitalWrite(IN2, sol < 0);
24  digitalWrite(IN3, sag > 0); digitalWrite(IN4, sag < 0);
25  analogWrite(ENA, abs(sol));
26  analogWrite(ENB, abs(sag));
27}
28
29void setup() {
30  Serial.begin(115200);
31  int pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
32  for (int p : pinler) pinMode(p, OUTPUT);
33  pinMode(ENC_SOL, INPUT);
34  pinMode(ENC_SAG, INPUT);
35  attachInterrupt(digitalPinToInterrupt(ENC_SOL), solDarbe, RISING);
36  attachInterrupt(digitalPinToInterrupt(ENC_SAG), sagDarbe, RISING);
37  sur(180, 180);                             // ileri / forward
38}
39
40void loop() {
41  delay(1000);
42  portENTER_CRITICAL(&kilit);
43  uint32_t sol = solSayac, sag = sagSayac;
44  solSayac = 0;
45  sagSayac = 0;
46  portEXIT_CRITICAL(&kilit);
47  Serial.printf("Sol / Left: %.0f d/dk  Sag / Right: %.0f d/dk\n",
48                sol * 60.0 / YARIK, sag * 60.0 / YARIK);   // 1 s'deki darbe -> d/dk / pulses in 1 s -> rpm
49}

TT-Motor mit Raspberry Pi Pico und MicroPython

Am Pico kann jeder GPIO PWM erzeugen. In MicroPython stellst du die Frequenz des PWM-Objekts auf 1 kHz und gibst die Geschwindigkeit mit duty_u16() im Bereich 0–65535 vor; 65535 bedeutet volle Drehzahl. Der folgende Code lässt den linken Motor mit verschiedenen Geschwindigkeiten laufen und misst die Drehzahl mit dem Encoder. Willst du den Pico aus derselben Batterie wie die Motoren versorgen, kannst du den 5V-Ausgang des L298N an VSYS anschließen.

MicroPython
1from machine import Pin, PWM
2import machine
3import time
4
5ena = PWM(Pin(15))                     # sol motor hızı / left motor speed
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9YARIK = 20
10sayac = 0
11
12def darbe(pin):                        # enkoder kesmesi / encoder interrupt
13    global sayac
14    sayac += 1
15
16enc = Pin(16, Pin.IN)
17enc.irq(trigger=Pin.IRQ_RISING, handler=darbe)
18
19def motor(hiz):                        # hiz: -100..100 (%)
20    in1.value(1 if hiz > 0 else 0)
21    in2.value(1 if hiz < 0 else 0)
22    ena.duty_u16(int(abs(hiz) * 65535 / 100))
23
24for hiz in (40, 60, 80, 100):
25    motor(hiz)
26    time.sleep(1)                      # hızlanmayı bekle / let it settle
27    durum = machine.disable_irq()
28    sayac = 0
29    machine.enable_irq(durum)
30    time.sleep(1)                      # 1 saniye say / count for 1 second
31    print("PWM %{}: {} d/dk".format(hiz, sayac * 60 // YARIK))
32motor(0)

TT-Motor oder N20-Mikromotor?

N20-Mikrogetriebemotor
N20-Mikrogetriebemotor: Metallzahnräder, 3-mm-D-Welle und etwa ein Fünftel des Volumens eines TT-Motors.
EigenschaftTT-Motor (gelb)N20-Mikromotor
GrößeEtwa 70 × 22 × 18 mmEtwa 12 × 10 mm Querschnitt, 25–35 mm lang
ZahnräderKunststoffMetall
Spannungsvarianten3–6 V3-V-, 6-V- und 12-V-Versionen
ÜbersetzungMeist 1:48 (1:120, 1:220)Große Auswahl von 1:10 bis 1:1000
WelleKunststoff, mit zwei Abflachungen3-mm-Metallwelle mit D-Profil
EncoderSeparate Scheibe und GabellichtschrankeVersionen mit hinten montiertem magnetischem Hall-Encoder sind verbreitet
Preis und HaltbarkeitSehr günstig, Zahnräder verschleißen mit der ZeitTeurer, präziser und langlebiger
Geeignete ProjekteLernroboter, Roboterauto-BausätzeMini-Sumo, schnelle Linienfolger, kleine Mechanismen

Kurz gesagt ist der TT-Motor dank niedrigem Preis und einfacher Montage der beste Einstieg für das erste Roboterauto und Schulprojekte. Brauchst du einen kleineren, präziseren und langlebigeren Mechanismus oder baust du einen Wettbewerbsroboter, ist der N20 die bessere Wahl; N20 mit Encoder messen an der Motorwelle und liefern so Hunderte Impulse pro Radumdrehung und eine viel genauere Drehzahlmessung. Einen Überblick, welcher Motortyp für welche Aufgabe passt, gibt der Artikel Unterschied zwischen DC-, Servo- und Schrittmotor.

Projektideen mit Getriebemotoren

  • Roboterauto: Bau mit zwei TT-Motoren, einem Stützrad und einem L298N ein per Bluetooth gesteuertes Auto; alle Schritte im Artikel Arduino-Roboterauto bauen.
  • Linienfolger: Folge mit Infrarotsensoren einer schwarzen Linie; hier ist der Gleichlauf der Motoren besonders wichtig. Siehe Linienfolger-Roboter.
  • Hindernisvermeider: Erkenne Hindernisse mit einem HC-SR04 und ändere die Richtung; Aufbau im Artikel Hindernis-Roboter.
  • Messrad: Roll ein Rad mit Encoder über den Boden und bau so ein digitales Maßband für Räume; jeder Impuls entspricht etwa 1 cm.
  • Automatischer Vorhang: Öffne den Vorhang morgens und schließe ihn abends mit einem TT-Motor 1:220; ausgelöst durch Licht mit einem LDR.
  • Drehteller für Ausstellungen: Bau mit einem langsamen Motor einen Teller, der ein kleines Produkt oder Modell langsam dreht.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
Motor brummt, dreht aber nichtPWM unterhalb der Totzone oder schwache BatterieMIN_PWM erhöhen, Batteriespannung messen
Motor läuft immer mit voller DrehzahlJumper an ENA/ENB gesteckt oder Pin ohne PWMJumper entfernen; am Uno die Pins 3, 5, 6, 9, 10, 11 nutzen
Auto fährt nicht geradeausFertigungsunterschied zwischen den MotorenMit Faktor ausgleichen oder mit Encodern einen Regelkreis bauen
Arduino startet neu, wenn der Motor läuftAnlaufstrom lässt die Akkuspannung einbrechen, Bürstenstörungen100 nF an die Motoranschlüsse, 470 µF an den Treibereingang; Arduino separat versorgen
Ein Rad dreht rückwärtsMotorkabel vertauschtDie beiden Kabel dieses Motors am Treiber tauschen
Drehzahl niedriger als erwartet2 V Verlust am L298NAkku mit höherer Spannung oder MOSFET-Treiber wie den TB6612FNG verwenden
Encoder zählt zu viele ImpulsePrellen der Lichtschranke an der Schlitzkante2-ms-Sperrzeit im Interrupt nutzen, Scheibe mittig in der Lichtschranke ausrichten
Teste nach dem Aufbau jeden Motor einzeln mit dem Rad in der Luft: Prüfe, ob vorwärts, rückwärts und Stopp richtig funktionieren und ob beide Motoren ungefähr gleich klingen. Klingt einer deutlich anders, hat sein Getriebe womöglich Reibung oder einen abgebrochenen Zahn; das Problem zu lösen, bevor der Roboter auf den Boden kommt, spart Stunden.

Der TT-Getriebemotor ist ein günstiges, aber sehr lehrreiches Bauteil, um den Zusammenhang von Drehzahl und Drehmoment bei einer Übersetzung, die Drehzahlregelung mit PWM und die Rückmeldung per Encoder zu lernen. Mit dem richtigen Treiber, ein paar Kondensatoren und einfachem Ausgleichscode fährt dein Roboter gerade und zuverlässig. In der BlueGrays-App findest du das Bluetooth-gesteuerte Auto, den Hindernis-Roboter und Projekte mit Infrarotsensoren samt Schritt-für-Schritt-Schaltplan und Code, sodass du diese Motoren sofort in ein Projekt verwandeln kannst.

Häufige Fragen

Was ist ein Getriebemotor?

Ein Getriebemotor ist ein kleiner, schnell drehender Gleichstrommotor mit einem Getriebe an der Welle. Die Zahnräder senken die Drehzahl und erhöhen das Drehmoment im gleichen Verhältnis; bei 1:48 dreht sich die Abtriebswelle einmal, während die Motorwelle 48 Umdrehungen macht. So kann ein kleiner Motor ein Roboterauto oder einen Mechanismus mühelos bewegen.

Mit welcher Spannung läuft ein TT-Motor?

Gelbe TT-Motoren laufen mit 3–6 V, die häufigste Versorgung sind 4 AA-Batterien. Bei 3 V drehen sie mit etwa 90–120 U/min, bei 6 V mit etwa 200–250 U/min. Mehr als 6 V machen den Motor schneller, lassen ihn aber heiß werden und das Getriebe schnell verschleißen.

Wie viel Strom zieht ein TT-Motor?

Im Leerlauf etwa 150 mA, in einem Roboter auf ebenem Boden 200–350 mA. Ist das Rad blockiert, kann der Strom bei 6 V auf 1,5 A steigen. Deshalb müssen Motortreiber und Akku nach dem Blockierstrom gewählt werden, und der Motor darf nie direkt an einem Arduino-Pin hängen.

Warum drehen zwei Gleichstrommotoren nicht gleich schnell?

Günstige Motoren unterscheiden sich bei Bürsten, Magneten, Getriebereibung und Schmierung; selbst beim gleichen PWM können die Drehzahlen um 10–20 % abweichen. Auch Akkuspannung und Temperatur verändern den Unterschied. Ein Faktor für den schnelleren Motor in der Software oder das Messen beider Raddrehzahlen mit Encodern und automatisches Nachregeln des PWM lösen das Problem.

Warum lötet man einen Kondensator an einen Gleichstrommotor?

Wenn Bürstenmotoren drehen, erzeugen kleine Funken an den Bürsten elektrische Störungen. Diese können den Arduino zurücksetzen, Sensoren falsch messen lassen und Funkverbindungen unterbrechen. Ein 100-nF-Keramikkondensator zwischen den Motoranschlüssen unterdrückt die Störungen direkt an der Quelle.

Wie misst man die Motordrehzahl mit einer Encoderscheibe?

Eine geschlitzte Scheibe auf der Motorwelle läuft durch eine optische Gabellichtschranke, und jeder Schlitz erzeugt einen Impuls. Der Arduino zählt diese Impulse per Interrupt; bei einer Scheibe mit 20 Schlitzen sind 20 Impulse eine Radumdrehung. Teilst du die Impulse einer Sekunde durch 20 und multiplizierst mit 60, erhältst du die Umdrehungen pro Minute.

Alle Projekte ansehen
Bluetooth-gesteuertes Auto mit L298N
AR-80Fortgeschritten
Premium

Bluetooth-gesteuertes Auto mit L298N

Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

5.0(39)
66
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

Roboter zur Hindernisvermeidung

Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.

5.0(38)
49
TCRT5000 Schwarz-Weiß-Untergrunderkennung
AR-78Mittel
Premium

TCRT5000 Schwarz-Weiß-Untergrunderkennung

Mit dem kleinen Sensor, der bei Linienfolger-Robotern als Auge dient, erkennst du, ob der Boden schwarz oder weiß ist.

4.7(40)
49
Reflexion (Nähe) mit TCRT5000 messen
AR-77Mittel
Premium

Reflexion (Nähe) mit TCRT5000 messen

Mit einem kleinen Sensor, der unsichtbares Licht aussendet und misst, wie viel davon zurückkommt, erkennst du die Fläche vor ihm.

4.6(33)
43
Servo-Steuerung mit Joystick
AR-60Mittel
Premium

Servo-Steuerung mit Joystick

Steuere zwei Motoren mit einem Joystick, genau wie beim Schwenken einer Überwachungskamera.

4.7(42)
58
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)

Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

4