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.

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.
| Eigenschaft | Gelber TT-Motor (1:48, typische Werte) |
|---|---|
| Betriebsspannung | 3–6 V DC |
| Übersetzung | 1:48 (es gibt auch 1:120 und 1:220) |
| Leerlaufdrehzahl am Abtrieb | Etwa 90–120 U/min bei 3 V, etwa 200–250 U/min bei 6 V |
| Leerlaufstrom | Etwa 150 mA |
| Blockierstrom | Etwa 1,2 A bei 4,5 V, etwa 1,5 A bei 6 V |
| Blockiermoment | Etwa 0,4 kg·cm bei 3 V, etwa 0,8 kg·cm bei 6 V |
| Welle | Beidseitige Kunststoffwelle mit zwei Abflachungen |
| Gehäuse und Zahnräder | Kunststoff; etwa 70 × 22 × 18 mm, 30 g |
| Rad | Etwa 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.
| Übersetzung | Abtriebsdrehzahl (6 V, Leerlauf) | Drehmoment | Geeignet für |
|---|---|---|---|
| 1:48 | Etwa 200–250 U/min | Mittel | Roboterauto, Linienfolger, Hindernisvermeider |
| 1:120 | Etwa 80–100 U/min | Hoch | Auto mit schwerer Last, langsame und kontrollierte Bewegung |
| 1:220 | Etwa 45–55 U/min | Sehr hoch | Tür, Vorhang, Drehteller, Sonnennachführung |
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.
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.
| Situation | Typischer Strom (6 V) | Was bedeutet das? |
|---|---|---|
| Rad in der Luft, Leerlauf | 150–170 mA | Reibung in Getriebe und Bürsten; der Motor ist in Ordnung |
| Roboter fährt auf ebenem Boden | 200–350 mA | Normalbetrieb; diesen Wert für die Akkurechnung nehmen |
| Rampe oder Teppich | 400–700 mA | Der Motor müht sich; 1:120 oder ein leichteres Chassis erwägen |
| Rad blockiert | 1,2–1,5 A | Schlimmster Fall für Treiber und Akku; dauert es an, wird der Motor heiß |
| Anfahren | Kurzzeitig bis 1 A | Kann 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

| Treiber | Strom pro Kanal | Spannungsabfall | Hinweis |
|---|---|---|---|
| L298N | 2 A | Etwa 1,5–2,5 V | Robust 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 V | Wird auf den Uno gesteckt, treibt vier Motoren; für TT grenzwertig |
| L9110S | 0,8 A | Gering | Klein und günstig; beim Blockierstrom überfordert |
| TB6612FNG | 1,2 A (Spitze 3,2 A) | Sehr gering (MOSFET) | Nutzt die Akkuspannung effizient, eine der besten Wahlen für TT |
| Verbindung | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (Drehzahl linker Motor, PWM) | D5 | GPIO 25 | GP15 |
| L298N IN1 / IN2 | D7 / D8 | GPIO 27 / GPIO 33 | GP14 / GP13 |
| L298N ENB (Drehzahl rechter Motor, PWM) | D6 | GPIO 26 | GP10 |
| L298N IN3 / IN4 | D9 / D4 | GPIO 32 / GPIO 4 | GP12 / GP11 |
| Ausgang linker / rechter Encoder (LM393) | D2 / D3 | GPIO 34 / GPIO 35 | GP16 / GP17 |
| VCC des Encodermoduls | 5V | 3V3 | 3V3(OUT) |
| GND | Batterie-Minus, L298N und Arduino-GND gemeinsam | Gemeinsam | Gemeinsam |
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
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.
- Lass den Roboter auf ebenem Boden 2–3 Meter mit gleichem PWM vorwärts fahren und notiere, wohin er zieht.
- Zieht das Auto nach rechts, ist der linke Motor schneller; senke SOL_KATSAYI auf 0,95 und probiere es erneut.
- Ändere den Faktor in Schritten von 0,01–0,02, bis das Auto geradeaus fährt; das dauert meist 3–5 Versuche.
- Mach denselben Test rückwärts; ist der Unterschied groß, nutze getrennte Faktoren für vorwärts und rückwärts.
- Ä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.
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.
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.
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?

| Eigenschaft | TT-Motor (gelb) | N20-Mikromotor |
|---|---|---|
| Größe | Etwa 70 × 22 × 18 mm | Etwa 12 × 10 mm Querschnitt, 25–35 mm lang |
| Zahnräder | Kunststoff | Metall |
| Spannungsvarianten | 3–6 V | 3-V-, 6-V- und 12-V-Versionen |
| Übersetzung | Meist 1:48 (1:120, 1:220) | Große Auswahl von 1:10 bis 1:1000 |
| Welle | Kunststoff, mit zwei Abflachungen | 3-mm-Metallwelle mit D-Profil |
| Encoder | Separate Scheibe und Gabellichtschranke | Versionen mit hinten montiertem magnetischem Hall-Encoder sind verbreitet |
| Preis und Haltbarkeit | Sehr günstig, Zahnräder verschleißen mit der Zeit | Teurer, präziser und langlebiger |
| Geeignete Projekte | Lernroboter, Roboterauto-Bausätze | Mini-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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Motor brummt, dreht aber nicht | PWM unterhalb der Totzone oder schwache Batterie | MIN_PWM erhöhen, Batteriespannung messen |
| Motor läuft immer mit voller Drehzahl | Jumper an ENA/ENB gesteckt oder Pin ohne PWM | Jumper entfernen; am Uno die Pins 3, 5, 6, 9, 10, 11 nutzen |
| Auto fährt nicht geradeaus | Fertigungsunterschied zwischen den Motoren | Mit Faktor ausgleichen oder mit Encodern einen Regelkreis bauen |
| Arduino startet neu, wenn der Motor läuft | Anlaufstrom lässt die Akkuspannung einbrechen, Bürstenstörungen | 100 nF an die Motoranschlüsse, 470 µF an den Treibereingang; Arduino separat versorgen |
| Ein Rad dreht rückwärts | Motorkabel vertauscht | Die beiden Kabel dieses Motors am Treiber tauschen |
| Drehzahl niedriger als erwartet | 2 V Verlust am L298N | Akku mit höherer Spannung oder MOSFET-Treiber wie den TB6612FNG verwenden |
| Encoder zählt zu viele Impulse | Prellen der Lichtschranke an der Schlitzkante | 2-ms-Sperrzeit im Interrupt nutzen, Scheibe mittig in der Lichtschranke ausrichten |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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.

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

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.

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

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.

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

